/********************************************************************
created:	2014/08/05
created:	5:8:2014   16:08
filename: 	e:\WorkCode\QuoteBoard V6\include\SSQBModel.h
file path:	e:\WorkCode\QuoteBoard V6\include
file base:	SSQBModel
file ext:	h
author:		Alger

purpose:	QB 和服务端通用接口
*********************************************************************/
#ifndef SS_BONDMODEL_H_
#define SS_BONDMODEL_H_

#pragma warning(disable : 4996)

#include <list>
#include <map>
#include <set>

#include "variant.h"
/*
#ifndef WIN32
#define min(x, y) ({				\
        typeof(x) _min1 = (x);			\
        typeof(y) _min2 = (y);			\
        (void) (&_min1 == &_min2);		\
        _min1 < _min2 ? _min1 : _min2; })

#define max(x, y) ({				\
        typeof(x) _max1 = (x);			\
        typeof(y) _max2 = (y);			\
        (void) (&_max1 == &_max2);		\
        _max1 > _max2 ? _max1 : _max2; })
#endif
*/

typedef unsigned char BYTE; /* 8-bits  0 to 255*/
typedef int INT;
typedef short SHORT;
typedef unsigned short USHORT;
typedef unsigned int UINT;
typedef long LONG;
typedef unsigned long ULONG;
typedef int64_t int64;

#ifndef _countof
#define _countof(array) (sizeof(array) / sizeof(array[0]))
#endif

//--初始化char[]
#define _InitializeString(Name) memset(Name, 0, _countof(Name));

#ifndef __FIELDCOPY__
#ifdef WIN32
#define __FIELDCOPY__(field, dest) \
  strncpy_s(field, _countof(field), dest, _TRUNCATE)
#else
#define __FIELDCOPY__(field, dest) strcpy(field, dest)
#endif
#endif

#include "SSFilters.h"

#define SELECTIVE_CODE_LEN 6
#define INVALID_VALUE_CAL -999999

#ifndef PRICE_LEN
#define PRICE_LEN 8
#endif
#ifndef VOLUME_LEN
#define VOLUME_LEN 10
#endif

#define _InitializePureStruct(Name) \
  Name() { memset(this, 0, sizeof(Name)); }

enum ePeriod {          // 统计周期粒度
  periodUnknown = 'A',  // 未知
  periodD1 = 'B',       // 1日
  periodD3 = 'C',       // 3日
  periodW1 = 'D',       // 1周
  periodW2 = 'E',       // 1周
  periodM1 = 'F',       // 1月
  periodM3 = 'G',       // 3月
  periodM6 = 'H',       // 6月
  periodS1 = 'I',       // 1季度
  periodY1 = 'J',       // 1年
};

enum eOrderError {  // 报价错误信息

  error_order_ok = 0,
  error_order_unknow = 1,  // Unknown error
  error_order_2 = 2,       // Unable to get goodsId
  error_order_3 = 3,       // Unable to get goods
  error_order_4 = 4,       // Unable to get traderId
  error_order_5 = 5,       // Unable to get agent ,	没有报价权限
  error_order_6 = 6,       // Add offer Program error
  error_order_7 = 7,       // Refer offer Program error
  error_order_8 = 8,       // Edit offer Program error	　
  error_order_9 = 9,       // Program error

};

typedef struct xMsg_RequestCommHead {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyID[32 + 1];  // 用户所在机构ID
  xMsg_RequestCommHead() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_CompanyID, 0, sizeof(m_CompanyID));
  }
} Msg_RequestCommHead, *PMsg_RequestCommHead;

typedef struct xMsg_AckHead {
  bool m_Errcode;       // 错误代码，0--执行成功
  char m_Errinfo[128];  // 错误信息，如果有的话
  UINT m_Curidx;        // 当前包序号，不分包为0
  UINT m_Total;         // msg 总的包数，不分包为1
  float m_Exectime;     // 执行时间,单位秒，如 0.02
  xMsg_AckHead() : m_Errcode(false), m_Curidx(0), m_Total(0), m_Exectime(0) {
    memset(m_Errinfo, 0, sizeof(m_Errinfo));
  }
} Msg_AckHead, *PMsg_AckHead;

typedef struct tagBOND_STRUCTEx {
  char m_BondKey[32 + 1];  // bondKey;				唯一
  char m_ListedMarket[8];  // 市场代码
  char m_BondID[12];       // bond ID、bond code;	唯一,除非为空
  char m_Bond_Type[SELECTIVE_CODE_LEN];  // bond's type
  tagBOND_STRUCTEx() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Bond_Type, 0, sizeof(m_Bond_Type));
  }
} BOND_STRUCTEx, *PBOND_STRUCTEx;
typedef BOND_STRUCTEx TW_BOND;

// E_FID_QB_SEND_CLIENT_INFO					= 40001,
// // 上传客户端信息
typedef struct xQBSendClientInfo_t {
  char m_PriceFlag[32];     // V5
  char m_VersionLable[32];  // 实际显示版本号 如1.5.1
  char m_CompanyID[32 + 1];
  char m_CpuParam[64];       // cpu型号及主频，格式 型号<主频>
  char m_MemSize[32];        // 内存大小
  char m_OSVersion[80];      // windows版本
  char m_PowerPlanName[32];  // 电池管理计划（节能、平衡）
  char m_TimeSpanScreenShutDown[32];  // 无操作情况下多久关闭显示器，单位分钟
  char m_TimeSpanSleep[32];  // 无操作情况下多久计算机进入睡眠状态，单位分钟
  char m_ServerIPnPort
      [32];  // 客户端连接的网关服务器IP地址与端口，以类似140.206.61.218:28899格式表示
  xQBSendClientInfo_t() { memset(this, 0, sizeof(xQBSendClientInfo_t)); };
} QBSendClientInfo_t, *PQBSendClientInfo_t;

// E_FID_QB_DICT_CHECK = 40005,		// 字典校验
class QBDictCheck_Req {
 public:
  char m_PatchName[32];  // 字典名称
  char* m_Pack;          // 压缩后的buffer
  int m_PackLength;      // 压缩后的buffer长度
  int m_Min;             // 最小Sequence
  int m_Max;             // 最大Sequence
  QBDictCheck_Req() : m_Pack(NULL), m_PackLength(0), m_Min(0), m_Max(0) {
    memset(m_PatchName, 0, sizeof(m_PatchName));
  };
  ~QBDictCheck_Req() {
    if (m_Pack) delete m_Pack;
    m_Pack = NULL;
  };
};

class QBDictCheck_Ack {
 public:
  char m_PatchName[32];  // 字典名称
  int m_retcode;         // 1 = 验证正确； 0 = 验证错误

  // 当retcode==1时，下面参数无效
  char m_Md5[64];  // 最后一个正确的更新包的md5
  int m_UpdateId;  // 最后一个正确的更新包的updateid

  QBDictCheck_Ack() {
    memset(m_PatchName, 0, sizeof(m_PatchName));
    memset(m_Md5, 0, sizeof(m_Md5));
    m_retcode = 0;
    m_UpdateId = 0;
  };
};

//--------------------------------------------------------------------------
// E_FID_QB_CDC_AUTHORITY_REQ					= 50030,
// // 请求估值权限
struct xCDCAuthorityReq_c {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  xCDCAuthorityReq_c() { memset(this, 0, sizeof(xCDCAuthorityReq_c)); };
};

struct xCDCAuthorityOldAck_c {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  int m_Allowed;             // 估值权限，0=无权限，1=有权限
  xCDCAuthorityOldAck_c() { memset(this, 0, sizeof(xCDCAuthorityOldAck_c)); };
};

// E_FID_QB_CDC_AUTHORITY_REQ_V2				= 50340,
// //请求中债估值权限，V3.6后替换原56030消息 请求同50030
struct xCDCAuthorityUnit {
  char m_AuthName[64];
  char m_AuthNameEn[64];
  int m_AuthValue;
  xCDCAuthorityUnit() { memset(this, 0, sizeof(xCDCAuthorityUnit)); }
};

struct xCDCAuthorityAct_c {
  xCDCAuthorityReq_c m_user;
  std::list<xCDCAuthorityUnit> m_AuthList;
};

// E_FID_QBA_CDC_PRICE_ALL_REQ_V2 = 50341,
// //请求当天中债估值，根据权限，V3.6后替换原53014消息
// E_FID_QBA_CDC_PRICE_ALL_REQ_V3 = 50679
// //请求单券的中债估值，包括含权债券的行权估值和到期估值
// E_FID_QBA_CDC_PRICE_SPECIAL_REQ				= 50680,
// //请求中债特殊债券估值权限 请求
struct xQBCDCPriceAllReq_t {
  std::list<int> m_AuthList;
};

// 应答如下，按字典格式保存，客户端解析的时候拿到VariantRaw解析到xQBACDCPriceList_c，再给缓存赋值
class xQBCDCPriceAll_c {
 public:
  qb::proto::VariantRaw m_CDCPrice;  // 二进制中债估值数据,
};

class xQBACDCPriceUnit_c {
 public:
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_listedmarket[8];   // 市场代码
  int m_BondProperty;       // 债券性质，中债登给
  int m_Custodian;          // 托管机构，中债登给
  int m_Authority;          // 中债权限
  char m_est_option
      [8];  // 中债估值对应的含权属性,对应CBondInfo.m_sEstOption，3种取值：行权/到期/(空)
  char m_CleanPrice[10];       // 净价
  char m_Yield[10];            // 收益率
  char m_FrontCleanPrice[10];  // 上一次 净价
  char m_FrontYield[10];       // 上一次  收益率
  char m_Duration[10];         // 久期
  UINT m_Date;                 // 日期

  xQBACDCPriceUnit_c()
      : m_BondProperty(0), m_Custodian(0), m_Authority(0), m_Date(0) {
    _InitializeString(m_bond_key);
    _InitializeString(m_listedmarket);
    _InitializeString(m_est_option);
    _InitializeString(m_CleanPrice);
    _InitializeString(m_Yield);
    _InitializeString(m_FrontCleanPrice);
    _InitializeString(m_FrontYield);
    _InitializeString(m_Duration);
  }
};

class xQBACDCPriceList_c {
 public:
  std::list<xQBACDCPriceUnit_c> m_List;  //
};

class xQBACDCPriceUnitV2_c {
 public:
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_listedmarket[8];   // 市场代码
  int m_BondProperty;       // 债券性质，中债登给
  int m_Custodian;          // 托管机构，中债登给
  int m_Authority;          // 中债权限
  char m_est_option
      [8];  // 中债估值对应的含权属性,对应CBondInfo.m_sEstOption，3种取值：行权/到期/(空)
  float m_CleanPrice;       // 净价
  float m_Yield;            // 收益率
  float m_FrontCleanPrice;  // 上一次 净价
  float m_FrontYield;       // 上一次  收益率
  float m_Duration;         // 久期
  UINT m_Date;              // 日期
  bool m_bPriceValid;
  bool m_bYieldValid;
  bool m_bDurationValid;
  bool m_bOptionValid;  // 字段m_est_option是否有效
  bool m_bPrePriceValid;
  bool m_bPreYieldValid;
};

class xQBACDCPriceListV2_c {
 public:
  std::list<xQBACDCPriceUnitV2_c> m_List;  //
};

class xQBACDCPriceUnit_c_Old {
 public:
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_listedmarket[8];   // 市场代码
  int m_BondProperty;       // 债券性质，中债登给
  int m_Custodian;          // 托管机构，中债登给
  int m_Authority;          // 中债权限
  char m_est_option
      [8];  // 中债估值对应的含权属性,对应CBondInfo.m_sEstOption，3种取值：行权/到期/(空)
  float m_CleanPrice;  // 净价
  float m_Yield;       // 收益率
  float m_Duration;    // 久期
  UINT m_Date;         // 日期
  bool m_bPriceValid;
  bool m_bYieldValid;
  bool m_bDurationValid;
  bool m_bOptionValid;  // 字段m_est_option是否有效
};
class xQBACDCPriceList_c_Old {
 public:
  std::list<xQBACDCPriceUnit_c_Old> m_List;  //
};

//--------------------------------------------------------------------------
// E_FID_QB_BOND_SS_INFO_NEW				= 50034
// // 债券详情--取值sumscope的bond相关表,Vixen 设计
typedef struct xBondSSInfoNewReq_t {
  std::list<TW_BOND> m_Bond;  // 债券信息
} BondSSInfoNewReq_t, *PBondSSInfoNewReq_t;

class xBondSSListMarket_c {
 public:
  char m_Listed_Market[32];  // 发行市场
  char m_Bond_ID[12];        // 代码
  char m_Short_Name[32];     // 简称
  char m_Short_Name_En[64];  // 简称-英文
  float m_Conversion_rate;   // 质押比例
  xBondSSListMarket_c() : m_Conversion_rate(0) {
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Bond_ID, 0, sizeof(m_Bond_ID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
  }
};

class xBondRatingUnit_c {
 public:
  UINT m_Rating_Date;                   // 评级日期	P_bond_rating
  char m_Rating[7 + 1];                 // 债项评级	P_bond_rating
  char m_Rating_Institution_Name[128];  // 评级机构代码
  char m_OutLook[32];                   // 展望面
  char m_Type[32];                      // 机构类型
  char m_Rating_Institution_Code[32];   // 评级机构id
  const bool operator<(const xBondRatingUnit_c& obj) const {
    return (m_Rating_Date > obj.m_Rating_Date);
  }
  xBondRatingUnit_c() : m_Rating_Date(0) {
    memset(m_Rating, 0, sizeof(m_Rating));
    memset(m_Rating_Institution_Name, 0, sizeof(m_Rating_Institution_Name));
    memset(m_OutLook, 0, sizeof(m_OutLook));
    memset(m_Type, 0, sizeof(m_Type));
    memset(m_Rating_Institution_Code, 0, sizeof(m_Rating_Institution_Code));
  }
};

class xInstitutionUnit_c {
 public:
  char m_Full_Name_C[64];    // 机构全称
  char m_Full_Name_En[128];  // 机构全称-英文
  xInstitutionUnit_c() {
    memset(m_Full_Name_C, 0, sizeof(m_Full_Name_C));
    memset(m_Full_Name_En, 0, sizeof(m_Full_Name_En));
  }
};

class xBondSSInfoNew_c {  // 基本信息
 public:
  char m_BondKey[32 + 1];                        // bondKey;				唯一
  char m_BondListed_Market[SELECTIVE_CODE_LEN];  // 发行市场
  char m_BondID[12];         // bond ID、bond code;	唯一,除非为空
                             // //债券
  char m_Short_Name[32];     // 债券简称
  char m_Full_Name[96];      // 债券全称
  char m_Short_Name_En[64];  // 英文简称
  char m_Full_Name_En[128];  // 英文全称
  char m_Issuer_Rating_Current[7 + 1];  // 主体评级	bond
  char m_Rating_Current[7 + 1];         // 债项评级	bond
  char m_Issuer_Rating_Dept[64];        // 主体评级机构名称
  char m_Rating_Current_Dept[64];       // 债项评级机构名称
  char m_Issuer_Rating_Dept_En[128];    // 主体评级机构名称-英文
  char m_Rating_Current_Dept_En[128];   // 债项评级机构名称-英文

  char m_Bond_Subtype[SELECTIVE_CODE_LEN];  // 债劵子类别
  double m_Issue_Amount;                    // 实际发行量-发行规模	bond
  int m_Maturity_Term;                      // 偿还期限
  char m_Term_Unit[SELECTIVE_CODE_LEN];     // ，两字段合并显示;
  UINT m_Maturity_Date;                     // 到期日	bond
  char m_Option_Type[SELECTIVE_CODE_LEN];   // 含权类型	bond

  int m_Redemption_No;  // 还本方式
  char m_Redemption_Str[SELECTIVE_CODE_LEN];
  char m_Underwriter_Name
      [256];  // 主承销商
              // (同一债券若有多条记录,用';'隔开显示)P_underwriter_info
  char m_Underwriter_Name_En[256];  // 主承销商-英文
  char m_Rating_Augment[32];        // 增信方式，担保方式	bond
  char m_WarranterName[256];        // 担保公司名称
  // char			m_Coupon_Rate[32];
  // //利率方式，需下面四个字段整合
  char m_Coupon_Type[SELECTIVE_CODE_LEN];         // 利率方式
  int m_Fixing_MA_Days;                           // 利率平均天期
  char m_FRN_Index_ID[16 + 1];                    // 基础利率代码
  float m_Index_Rate;                             // 基础利率
  float m_Coupon_Rate_Spread;                     // 利差(%)
  float m_Coupon_Rate_Current;                    // 票面利率(%)	bond
  float m_Issue_Rate;                             // 发行利率	bond
  float m_Issue_Price;                            // 发行价格(元)	bond
  char m_Coupon_Frequency[SELECTIVE_CODE_LEN];    // 付息频率
  char m_Compound_Frequency[SELECTIVE_CODE_LEN];  // 计息频率
  std::list<xBondSSListMarket_c> m_ListedMarket;  // 发行市场

  UINT m_Issue_Start_Date;     // 发行起始日
  UINT m_Auction_Date_Start;   // 招标/建档日
  UINT m_Interest_Start_Date;  // 起息日	bond
  UINT m_Payment_Date;         // 缴款日
  UINT m_Listed_Date;          // 上市日	bond
  UINT m_Next_coupon_Date;     // 下次付息日	bond
  UINT m_Option_date;          // 行权日期
  UINT m_Delisted_Date;        // 下市日
  char m_Maturity_Term_New
      [8];  // 偿还期限,V1.9新加,因为之前的是int型，有小数情况出现

  std::list<xBondRatingUnit_c> m_BondRateList;  // 债项评级
  std::list<xInstitutionUnit_c> m_VenderList;   // 主承

  xBondSSInfoNew_c()
      : m_Issue_Amount(0),
        m_Maturity_Term(0),
        m_Maturity_Date(0),
        m_Redemption_No(0),
        m_Fixing_MA_Days(0),
        m_Index_Rate(0),
        m_Coupon_Rate_Spread(-999),
        m_Coupon_Rate_Current(0),
        m_Issue_Rate(0),
        m_Issue_Price(0),
        m_Issue_Start_Date(0),
        m_Auction_Date_Start(0),
        m_Interest_Start_Date(0),
        m_Payment_Date(0),
        m_Listed_Date(0),
        m_Next_coupon_Date(0),
        m_Option_date(0),
        m_Delisted_Date(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondListed_Market, 0, sizeof(m_BondListed_Market));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Full_Name, 0, sizeof(m_Full_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Full_Name_En, 0, sizeof(m_Full_Name_En));
    memset(m_Issuer_Rating_Current, 0, sizeof(m_Issuer_Rating_Current));
    memset(m_Rating_Current, 0, sizeof(m_Rating_Current));
    memset(m_Issuer_Rating_Dept, 0, sizeof(m_Issuer_Rating_Dept));
    memset(m_Rating_Current_Dept, 0, sizeof(m_Rating_Current_Dept));
    memset(m_Issuer_Rating_Dept_En, 0, sizeof(m_Issuer_Rating_Dept_En));
    memset(m_Rating_Current_Dept_En, 0, sizeof(m_Rating_Current_Dept_En));
    memset(m_Bond_Subtype, 0, sizeof(m_Bond_Subtype));
    memset(m_Term_Unit, 0, sizeof(m_Term_Unit));
    memset(m_Option_Type, 0, sizeof(m_Option_Type));
    memset(m_Redemption_Str, 0, sizeof(m_Redemption_Str));
    memset(m_Underwriter_Name, 0, sizeof(m_Underwriter_Name));
    memset(m_Underwriter_Name_En, 0, sizeof(m_Underwriter_Name_En));
    memset(m_Rating_Augment, 0, sizeof(m_Rating_Augment));
    memset(m_WarranterName, 0, sizeof(m_WarranterName));
    memset(m_Coupon_Type, 0, sizeof(m_Coupon_Type));
    memset(m_FRN_Index_ID, 0, sizeof(m_FRN_Index_ID));
    memset(m_Coupon_Frequency, 0, sizeof(m_Coupon_Frequency));
    memset(m_Compound_Frequency, 0, sizeof(m_Compound_Frequency));
    memset(m_Maturity_Term_New, 0, sizeof(m_Maturity_Term_New));
  }
};

class xQBBondSSInfoNewListAck_c {
 public:
  std::list<xBondSSInfoNew_c> m_List;  // 债券详情列表数据
};

//-------------------------------------------------------------------
// E_FID_QB_BOND_FRN_INDEX_INFO					=50813
// //请求浮息债相关信息，ABS计算器使用
struct xBondFRNIndexInfoReq {
  std::list<TW_BOND> m_Bond;  // 债券信息
};

struct xBondFRNIndexInfoUnit {                   // 基本信息
  char m_BondKey[32 + 1];                        // bondKey;				唯一
  char m_BondListed_Market[SELECTIVE_CODE_LEN];  // 发行市场
  char m_BondID[12];     // bond ID、bond code;	唯一,除非为空
                         // //债券
  UINT m_Maturity_Date;  // 到期日	bond
  char m_Coupon_Type[SELECTIVE_CODE_LEN];  // 利率方式
  int m_Fixing_MA_Days;                    // 利率平均天期
  char m_FRN_Index_ID[16 + 1];             // 基础利率代码
  double m_Index_Rate;                     // 基础利率

  UINT m_Next_coupon_Date;  // 下次付息日	bond

  xBondFRNIndexInfoUnit()
      : m_Fixing_MA_Days(0),
        m_Index_Rate(0),
        m_Next_coupon_Date(0),
        m_Maturity_Date(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondListed_Market, 0, sizeof(m_BondListed_Market));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Coupon_Type, 0, sizeof(m_Coupon_Type));
    memset(m_FRN_Index_ID, 0, sizeof(m_FRN_Index_ID));
  }
};

struct xBondFRNIndexInfoAck {
  std::list<xBondFRNIndexInfoUnit> m_List;  // 浮息债相关信息
};

//------------------------------------------------------------------
// E_FID_QB_BOND_SS_ISSUER_RATING_NEW			= 50035,
// // 债券详情--发行人 评级信息,取值sumscope的bond相关表 请求同50034
class xBondIssuerRating_c {  // 发行人信息- 发行人主体评级
 public:
  char m_BondKey[32 + 1];                       // bondKey;				唯一
  char m_Full_Name_C[64];                       // 发行人全称
  char m_Short_Name_C[32];                      // 发行人简称
  char m_Full_Name_En[128];                     // 发行人全称-英文
  char m_Short_Name_En[128];                    // 发行人简称-英文
  char m_Institution_Type[SELECTIVE_CODE_LEN];  // 企业性质
  std::list<xBondRatingUnit_c> m_BondIssuerRatingList;  // 发行人主体评级
  xBondIssuerRating_c() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_Full_Name_C, 0, sizeof(m_Full_Name_C));
    memset(m_Short_Name_C, 0, sizeof(m_Short_Name_C));
    memset(m_Full_Name_En, 0, sizeof(m_Full_Name_En));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Institution_Type, 0, sizeof(m_Institution_Type));
  }
};

class xQBBondSSIssuerNewRatingListAck_c {
 public:
  std::list<xBondIssuerRating_c> m_List;  // 发行人信息列表
};

//------------------------------------------------------------------
// E_FID_QB_BOND_SS_ISSUER_INFO_NEW			= 50100,
// // 债券详情--发行人 基本信息 请求同50034

class xBondIssuerInfo_c {
 public:
  char m_BondKey[32 + 1];                    // bondKey;				唯一
  char m_Listed_Market[SELECTIVE_CODE_LEN];  // 发行市场
  char m_Full_Name_C[64];                    // 发行人全称
  char m_Short_Name_C[32];                   // 发行人简称
  char m_Full_Name_En[128];                  // 发行人全称-英文
  char m_Short_Name_En[64];                  // 发行人简称-英文
  char m_Institution_Type[32];               // 企业性质
  char m_Org_Type[SELECTIVE_CODE_LEN];       // 组织形式
  char m_SW_Sector[64];                      // 一级行业
  char m_SW_Subsector[64];                   // 二级行业

  char m_Province[64];                 // 地区（省）
  char m_City[64];                     // 地区（市）
  char m_Stockholder_name[128];        // 控股股东
  char m_Stockholder_nameEn[128];      // 控股股东
  char m_Stockholder_type[32];         // 控股股东类型
  char m_Stockholding_percentage[16];  // 控股比例
  double m_Regd_Capital;               // 注册资本
  char m_Regd_Capital_Currency[12];    // 单位 元
  char m_Actual_Controller[128];       // 实际控制人
  char m_Actual_ControllerEn[128];     // 实际控制人
  char m_Actual_Controller_type[32];   // 实际控制人--类型
  char m_Business_Scope[4096];         // 经营范围

  char m_IssuerCode[16];  // 发行人代码
  xBondIssuerInfo_c() : m_Regd_Capital(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Full_Name_C, 0, sizeof(m_Full_Name_C));
    memset(m_Short_Name_C, 0, sizeof(m_Short_Name_C));
    memset(m_Full_Name_En, 0, sizeof(m_Full_Name_En));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Institution_Type, 0, sizeof(m_Institution_Type));
    memset(m_Org_Type, 0, sizeof(m_Org_Type));
    memset(m_SW_Sector, 0, sizeof(m_SW_Sector));
    memset(m_SW_Subsector, 0, sizeof(m_SW_Subsector));
    memset(m_Province, 0, sizeof(m_Province));
    memset(m_City, 0, sizeof(m_City));
    memset(m_Stockholder_name, 0, sizeof(m_Stockholder_name));
    memset(m_Stockholder_nameEn, 0, sizeof(m_Stockholder_nameEn));
    memset(m_Stockholder_type, 0, sizeof(m_Stockholder_type));
    memset(m_Stockholding_percentage, 0, sizeof(m_Stockholding_percentage));
    memset(m_Regd_Capital_Currency, 0, sizeof(m_Regd_Capital_Currency));
    memset(m_Actual_Controller, 0, sizeof(m_Actual_Controller));
    memset(m_Actual_ControllerEn, 0, sizeof(m_Actual_ControllerEn));
    memset(m_Actual_Controller_type, 0, sizeof(m_Actual_Controller_type));
    memset(m_Business_Scope, 0, sizeof(m_Business_Scope));
    memset(m_IssuerCode, 0, sizeof(m_IssuerCode));
  }
};

//--------------------------------------------------------------------------
// E_FID_QB_BOND_SS_ISSUER_RELEVANT_NEW		= 50038,
// // 债券详情--发行人 相关债券信息,取值sumscope的bond相关表 请求同50034
class xBondRelevantUnit_c {
 public:
  char m_BondKey[32 + 1];        // bondKey;				唯一
  char m_Listed_Market[32];      // 发行市场
  char m_Bond_ID[12];            // 代码
  char m_Short_Name[32];         // 简称
  char m_Short_Name_En[64];      // 简称-英文
  UINT m_Maturity_Date;          // 到期日	bond
  UINT m_Option_date;            // 行权日期
  char m_Rating_Current[7 + 1];  // 债项评级	bond
  double m_Issue_Amount;         // 流通规模
  const bool operator<(const xBondRelevantUnit_c& obj) const {
    return (m_Maturity_Date < obj.m_Maturity_Date);
  }
  xBondRelevantUnit_c()
      : m_Maturity_Date(0), m_Option_date(0), m_Issue_Amount(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Bond_ID, 0, sizeof(m_Bond_ID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Rating_Current, 0, sizeof(m_Rating_Current));
  }
};

class xQBBondSSIssuerNewRelevantListAck_c {
 public:
  char m_BondKey[32 + 1];                 // bondKey;				唯一
  char m_Listed_Market[32];               // 发行市场
  std::list<xBondRelevantUnit_c> m_List;  // 发行人信息列表

  xQBBondSSIssuerNewRelevantListAck_c() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
  }
};

//--------------------------------------------------------------------------
// 我的关注： 增删改查
//	E_FID_QB_ATTENTION_ADD2_V2					= 50730
//---   50718;		//50071,			// 我的关注：增
typedef struct xQBAttentionAddReq_t {
  char m_GroupId[32 + 1];       // 分类id
  char m_BondKey[32 + 1];       // bond key
  char m_BondCode[12];          // 债券代码
  char m_ListedMarket[8];       // 市场代码
  char m_UserId[32 + 1];        // 用户id
  double m_OfrPriceRangeBegin;  // 买入
  double m_BidPriceRangeBegin;  // 卖出
  int m_FlagAllow;              // 分享给我的经纪人标记
  int m_SortId;  // 排序ID，第一条则为0,新增了后面的SortId 自增1
  xQBAttentionAddReq_t()
      : m_OfrPriceRangeBegin(0),
        m_BidPriceRangeBegin(0),
        m_FlagAllow(0),
        m_SortId(0) {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondCode, 0, sizeof(m_BondCode));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBAttentionAddReq_t, *PQBAttentionAddReq_t;

class xQBAttentionAddAck_c {
 public:
  char m_AttentionId[80];       // 关注id
  int m_SortId;                 // 排序ID
  char m_GroupId[32 + 1];       // 关注id
  char m_GroupVersion[32 + 1];  // 关注组版本号
  char m_AttVersion[32 + 1];    // 我的关注版本号

  xQBAttentionAddAck_c() : m_SortId(0) {
    memset(m_GroupVersion, 0, sizeof(m_GroupVersion));
    memset(m_AttVersion, 0, sizeof(m_AttVersion));
  }
};

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
// xQBAttentionBatchAddAckList_c(List)//50076,	// 我的关注：批量增加增 tong
typedef struct xQBAttentionBatchAddReq_t {
  char m_BondKey[32 + 1];  // bond key
  char m_ListedMarket[8];  // 市场代码
  int m_SortId;  // 排序ID，第一条则为0,新增了后面的SortId 自增1
  xQBAttentionBatchAddReq_t() {
    m_SortId = 0;
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
  }
} QBAttentionBatchAddReq_t, *PQBAttentionBatchAddReq_t;

class xQBAttentionBatchAddReq_c {
 public:
  std::list<xQBAttentionBatchAddReq_t> m_List;  // 我的关注列表数据
  char m_UserId[32 + 1];                        // 用户id
  char m_GroupId[32 + 1];                       // 分类id
  xQBAttentionBatchAddReq_c() {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_UserId, 0, sizeof(m_UserId));
  }
};

class xQBAttentionBatchAddAck_c {
 public:
  char m_AttentionId[80];       // 关注id
  int m_SortId;                 // 排序ID
  char m_GroupId[32 + 1];       // 分类id
  char m_BondKey[32 + 1];       // bond key
  char m_ListedMarket[8];       // 市场代码
  char m_GroupVersion[32 + 1];  // 关注组版本号
  xQBAttentionBatchAddAck_c() : m_SortId(0) {
    memset(m_AttentionId, 0, sizeof(m_AttentionId));
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_GroupVersion, 0, sizeof(m_GroupVersion));
  }
};

class xQBAttentionBatchAddAckList_c {
 public:
  char m_AttVersion[32 + 1];                    // 我的关注版本号
  std::list<xQBAttentionBatchAddAck_c> m_List;  // 我的关注列表数据

  xQBAttentionBatchAddAckList_c() {
    memset(m_AttVersion, 0, sizeof(m_AttVersion));
  }
};

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_DEL_V2					= 50731
// // 我的关注：删
typedef struct xQBAttentionDelReq_t {
  char m_AttentionId[80];  // 关注id，删除后后面的sortidx 自动减1
  char m_UserId[32 + 1];   // 用户id
  xQBAttentionDelReq_t() {
    memset(m_AttentionId, 0, sizeof(m_AttentionId));
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBAttentionDelReq_t, *PQBAttentionDelReq_t;
// 应答同E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
// xQBAttentionBatchAddAckList_c(List)		//50076,	//
// 我的关注：批量增加增 tong

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_BATCH_DEL_V2					= 50737
// ---  50722,			// 我的关注：删
typedef struct xQBAttentionBatchDelReq_t {
  std::list<xQBAttentionDelReq_t> m_List;  // 我的关注列表数据
} QBAttentionBatchDelReq_t, *PQBAttentionBatchDelReq_t;
// 应答同 E_FID_QB_ATTENTION_BATCH_ADD_V2 = 50736,
// xQBAttentionBatchAddAckList_c(List)	//50076,	// 我的关注：批量增加增
// tong

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_QRY_V2					50733   -- 50719
// = 50074,			// 我的关注：查 E_FID_QB_ATTENTION_GROUP_QRY_V2
// 50741	  --    50717			= 50028, // 我的关注：查询分组
typedef struct xQBAttentionQryReq_t {
  char m_UserId[32 + 1];  // 用户id
  char m_Product[12];     // 分组所对应的产品，"Bond","MM","IRS"
                       // ......,查所有填'ALL',不填则默认成'Bond' 处理
  xQBAttentionQryReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_Product, 0, sizeof(m_Product));
  }
} QBAttentionQryReq_t, *PQBAttentionQryReq_t;

class xQBAttentionInfo_c {
 public:
  char m_GroupId[32 + 1];       // 分类id
  char m_BondKey[32 + 1];       // bond key
  char m_BondCode[12];          // 债券代码
  char m_ListedMarket[8];       // 市场代码
  char m_AttentionId[80];       // 关注id
  char m_GroupVersion[32 + 1];  // 关注组版本号
  double m_OfrPriceRangeBegin;  // 买入
  double m_BidPriceRangeBegin;  // 卖出
  int m_FlagAllow;              // 分享给我的经纪人标记
  int m_SortId;                 // 排序ID
  xQBAttentionInfo_c()
      : m_OfrPriceRangeBegin(0),
        m_BidPriceRangeBegin(0),
        m_FlagAllow(0),
        m_SortId(0) {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondCode, 0, sizeof(m_BondCode));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_AttentionId, 0, sizeof(m_AttentionId));
    memset(m_GroupVersion, 0, sizeof(m_GroupVersion));
  }
};

class xQBAttentionGroupInfo_c {
 public:
  char m_GroupId[32 + 1];  // 分类id
  char m_GroupName[32];    // 分类名
  int m_GroupSortID;       // 组的排序
  int m_IsDefault;  // 是否是默认分组，0:不是默认分组；1:是默认分组
  char m_Product[12];  // 分组所对应的产品，"Bond","MM","IRS" ......
  char m_GroupVersion[32 + 1];  // 关注组版本号
  xQBAttentionGroupInfo_c() : m_GroupSortID(0) {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_GroupName, 0, sizeof(m_GroupName));
    memset(m_Product, 0, sizeof(m_Product));
    memset(m_GroupVersion, 0, sizeof(m_GroupVersion));
    m_IsDefault = 0;
  }
};

class xQBAttentionInfoListAck_c {
 public:
  std::list<xQBAttentionInfo_c> m_List;            // 我的关注列表数据
  std::list<xQBAttentionGroupInfo_c> m_GroupList;  // 我的关注分类列表数据

  xQBAttentionInfoListAck_c() { memset(m_AttVersion, 0, sizeof(m_AttVersion)); }
  char m_AttVersion[32 + 1];  // 我的关注版本号
};
//--------------------------------------------------------------------------
// 我的关注分类：增
// E_FID_QB_ATTENTION_GROUP_ADD_V2		50738  50713		= 50024,
typedef struct xQBAttentionGroupAddReq_t {
  char m_UserId[32 + 1];  // 用户id
  char m_GroupName[32];   // 分类名
  char m_Product[12];     // 分组所对应的产品，"Bond","MM","IRS" ......
  xQBAttentionGroupAddReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_GroupName, 0, sizeof(m_GroupName));
    memset(m_Product, 0, sizeof(m_Product));
  }
} QBAttentionGroupAddReq_t, *PQBAttentionGroupAddReq_t;

class xQBAttentionGroupAddAck_c {
 public:
  char m_GroupId[32 + 1];       // 分类id
  int m_SortIdx;                // 排序
  char m_GroupVersion[32 + 1];  // 关注组版本号
  char m_AttVersion[32 + 1];    // 我的关注版本号
  xQBAttentionGroupAddAck_c() : m_SortIdx(0) {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_AttVersion, 0, sizeof(m_AttVersion));
    memset(m_GroupVersion, 0, sizeof(m_GroupVersion));
  }
};

// 我的关注分类：删
// E_FID_QB_ATTENTION_GROUP_DEL_V2		50739---		= 50025,
// 50714
typedef struct xQBAttentionGroupDelReq_t {
  char m_GroupId[32 + 1];  // 分类id
  xQBAttentionGroupDelReq_t() { memset(m_GroupId, 0, sizeof(m_GroupId)); }
} QBAttentionGroupDelReq_t, *PQBAttentionGroupDelReq_t;
////应答同E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
///xQBAttentionBatchAddAckList_c(List)	//50076,	// 我的关注：批量增加增
///tong

// 我的关注：改--分类
// E_FID_QB_ATTENTION_GROUP_MDF_V2		50740---		= 50715
// 50026,
typedef struct xQBAttentionGroupMdfReq_t {
  char m_GroupId[32 + 1];  // 分类id
  char m_GroupName[32];    // 分类名
  xQBAttentionGroupMdfReq_t() {
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_GroupName, 0, sizeof(m_GroupName));
  }
} QBAttentionGroupMdfReq_t, *PQBAttentionGroupMdfReq_t;
////应答同E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
///xQBAttentionBatchAddAckList_c(List)	//50076,	// 我的关注：批量增加增
///tong

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_SORT_V2						= 50014,
// 50711		// 客户排序修改，
typedef struct xQBAttentionSortReq_t {
  char m_UserId[32 + 1];   // 用户id
  char m_GroupId[32 + 1];  // 分类id
  // From 移到End，结果： {FromSortID = EndSortID，(FromSortID， EndSortID]--;
  // FromSortID< EndSortID} 或者 {FromSortID =
  // EndSortID，[EndSortID,FromSortID)++; FromSortID>=EndSortID};
  char m_FromAttentionId[32 + 1];  // 关注id
  int m_FromSortId;                // 排序ID

  char m_EndAttentionId[32 + 1];  // 关注id，空则为移到最后
  int m_EndSortId;                // 排序ID,
  xQBAttentionSortReq_t() : m_FromSortId(0), m_EndSortId(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_FromAttentionId, 0, sizeof(m_FromAttentionId));
    memset(m_EndAttentionId, 0, sizeof(m_EndAttentionId));
  }
} QBAttentionSortReq_t, PQBAttentionSortReq_t;
////应答同E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
///xQBAttentionBatchAddAckList_c(List)	//50076,	// 我的关注：批量增加增
///tong

//-------------------------------------------------------------------------------------
//--E_FID_QB_ATTENTION_DEFAULT_V2			50735--		= 50712
//50022,			// 设置或者取消“我的关注”的默认值

// request
// E_FID_QB_ATTENTION_DEFAULT_V2
// 50022,设置或者取消“我的关注”的默认值
// xQBBondAttentionDefaultReq
class xQBBondAttentionDefaultReq_c {
 public:
  // GroupId
  char m_GroupId[32 + 1];  // 分类id
  // UserID
  char m_UserID[32 + 1];  // 当前用户ID
  // IsDefault
  int m_IsDefault;  // 是否是默认分组，0:不是默认分组；1:是默认分组
  // FunctionBegin
  // 初始值
  xQBBondAttentionDefaultReq_c() {
    _InitializeString(m_GroupId);
    _InitializeString(m_UserID);
    m_IsDefault = 0;
  }
  // FunctionEnd
};

// response
// E_FID_QB_ATTENTION_DEFAULT_V2
// 50022,设置或者取消“我的关注”的默认值
// xQBBondAttentionDefaultAck
class xQBBondAttentionDefaultAck_c : public xQBBondAttentionDefaultReq_c {
 public:
  char m_AttVersion[32 + 1];  // 我的关注版本号

  xQBBondAttentionDefaultAck_c() {
    memset(m_AttVersion, 0, sizeof(m_AttVersion));
  }
};

//--------------------------------------------------------------------------
// E_FID_QB_ATTENTION_GROUP_SORT_V2				=  50742 ---
// 50187,			//我的关注分组排序
typedef struct xQBAttentionGroupSortReq_t {
  char m_UserId[32 + 1];   // 用户id
  char m_GroupId[32 + 1];  // 分类ID
  // From 移到End，结果： {FromSortID = EndSortID，(FromSortID， EndSortID]--;
  // FromSortID< EndSortID} 或者 {FromSortID =
  // EndSortID，[EndSortID,FromSortID)++; FromSortID>=EndSortID};
  char m_FromGroupId[32 + 1];  // 分类ID
  int m_FromSortId;            // 排序ID

  char m_EndGroupId[32 + 1];  // 分类ID，空则为移到最后
  int m_EndSortId;            // 排序ID
  xQBAttentionGroupSortReq_t() : m_FromSortId(0), m_EndSortId(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_GroupId, 0, sizeof(m_GroupId));
    memset(m_FromGroupId, 0, sizeof(m_FromGroupId));
    memset(m_EndGroupId, 0, sizeof(m_EndGroupId));
  }
} QBAttentionGroupSortReq_t, *PQBAttentionGroupSortReq_t;

////应答同E_FID_QB_ATTENTION_BATCH_ADD_V2				= 50736,
///xQBAttentionBatchAddAckList_c(List)	//50076,	// 我的关注：批量增加增
///tong

//--------------------------------------------------------------------------
// 经纪公司: 查
// E_FID_QB_ALL_CMPY_QRY						= 50015,
// // 查询所有经纪公司 请求
struct xQBBasicRequestWithUser {
  char m_UserId[32 + 1];  // 用户id
  xQBBasicRequestWithUser() { memset(m_UserId, 0, sizeof(m_UserId)); }
};
typedef xQBBasicRequestWithUser QBTradeCmpyQryReq_t;

struct xQBTradeCmpContact_c {
 public:
  int m_ID;                 // 联系人ID， 主键
  int m_CompanyId;          // 公司id
  char m_Contact[32];       // 联系人
  char m_EName[32];         // 英文名
  char m_TEL[32];           // 电话
  char m_Dept[64];          // 部门
  char m_QM[32];            // sumscope IM
  char m_QQ[32];            //
  char m_MSN[32];           //
  char m_RM[64];            //
  char m_QQEnterprise[32];  // 企点QQ号
  xQBTradeCmpContact_c() { memset(this, 0, sizeof(xQBTradeCmpContact_c)); }
};

class xQBTradeCmpyInfo_c {
 public:
  int m_Id;                 // 公司id
  char m_BrokerID[32 + 1];  // BrokerID,
  char m_Name[32];          // 公司名
  char m_Code[32];          // 公司code
  char m_EnName[32];        // 英文名
  char m_FullName[64];      // 全称
  // char		m_BusinessCode[32 + 1];	//
  // 业务代码，空=全部，BOND=债券，NCD=NCD
  //-------------------------------------------------增加经纪公司联系方式,用于日评的页面显示
  char m_Address[256];  // 地址
  char m_PostCode[12];  // 邮编
  char m_Tel[32];       // 电话
  char m_Fax[32];       // 传真
  char m_Email[64];     // email

  xQBTradeCmpyInfo_c() { memset(this, 0, sizeof(xQBTradeCmpyInfo_c)); }
};

class xQBTradeCmpyInfoListAck_c {
 public:
  std::list<xQBTradeCmpyInfo_c> m_List;           // 经纪公司列表数据
  std::list<xQBTradeCmpContact_c> m_ContactList;  // 联系方式列表
  int m_SaveType;  // 0表示默认值(不修正状态位，兼容旧版)，1表示保存上一次值
                   // ，2表示不保存上一次值
  xQBTradeCmpyInfoListAck_c() : m_SaveType(0) {}
};

//--------------------------------------------------------------------------
// E_FID_QB_BEST_PRICE_REQ						= 50121,
// // 请求最优报价 E_FID_QB_BONDCOP_BEST_PRICE_REQ
// = 50141,			// 请求机构二级债券最优报价
struct xQBBestPriceItem_t {
  char m_BrokerID[32 + 1];  // BrokerID,
  // char	m_BusinessCode[32 + 1]; // 业务代码，空 = 全部， BOND = 债券，
  // NCD = NCD
  int m_VersionFrom;  // 默认为0，表示从头开始。
  int m_VersionTo;    // 默认为－1，表示一直到最后一个版本
  xQBBestPriceItem_t() { memset(this, 0, sizeof(xQBBestPriceItem_t)); };
};

typedef struct xQBBestPriceReq_t {
  std::list<xQBBestPriceItem_t> m_List;  // 经纪公司列表数据
} QBBestPriceReq_t, *PQBBestPriceReq_t;

struct xQBBestPriceUnit_c {
 public:
  char m_id[32 + 1];       // id
  char m_bondkey[32 + 1];  // 产品ID',== bondkey
  char m_listedmarket[8];  // 市场代码
  // char		m_bond_code[12];			//债券代码',
  // char		m_bond_shorname[32];		//简称
  char m_symbol[4];  // bid/ask标识',1--bid,-1,ofr
  char m_price[12];  // 收益率',
  char m_quotetype[4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  char m_tradePrice[12];  // 成交价格 (交易所报价页面使用，王绍旭 2015/01/22)

  char m_clean_price[12];  // 净价
  char m_full_price[12];   // 全价
  char m_yield[12];        // 收益率
  char m_volume[64];       // 数量，总价',
  char m_bp_status[8];  // m_deal_status, 与成交区分，故改为m_bp_status,
                        // 订单状态 \n-1：待审核 \n0：发布\n1：成交\n2：作废',
  char m_desc_useless[128];       // 无用字段
  char m_price_description[128];  // 价格备注：如明天+1',
  char m_interpret[128];  // 拆解后的报价，格式(T+0,2000;T+1,2000;远期,2000)，Add
                          // by Lance, 2021/09/10
  char m_flag_bargain[8];   // 可议价*',
  char m_flag_relation[8];  // OCO',
  char m_flag_vip[8];       // vip标记',
  char m_company_id[33];    // 经纪公司ID',
  // char		m_company_name[64];			//经纪公司名称',
  char m_fin_company_name[64];  // 报价机构',
  char m_flag_bad[8];           // 危险标记',
  char m_status[3];             //,
  time_t m_modify_time;         // datetime DEFAULT NULL,
  time_t m_create_time;         // datetime DEFAULT NULL,
  int m_version;     // 版本索引，每个公司唯一自增，从0开始
  char m_rebate[4];  // 是否返点(0-不返，1返点)
  char m_return_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  char m_price_status[3];  // 价格状态，0:报价被refer或deal掉了（UI灰色显示）
                           // 1:报价发布或者报价删除或者内部报价，按原逻辑显示
  char m_trade_clear_Price[12];  // 成交净价 (交易所报价页面使用，王绍旭
                                 // 2015/4/09, Anson)
  char m_exercise[2];  //'0'-行权，'1'-到期

  xQBBestPriceUnit_c() { memset(this, 0, sizeof(xQBBestPriceUnit_c)); };
};

class xQBBestPriceVersionUnit_c {
 public:
  char m_company_id[32 + 1];  // 经纪公司ID',
  int m_version;
  xQBBestPriceVersionUnit_c() : m_version(0) {
    memset(m_company_id, 0, sizeof(m_company_id));
  }
};

class xQBBestPriceListAck_c {
 public:
  std::list<xQBBestPriceUnit_c> m_List;  // 最优报价列表数据
  std::list<xQBBestPriceVersionUnit_c>
      m_extList;  // 版本信息列表，请求的时候返回最新的版本号，推送list为空，补推送也为空
  char m_BusinessCode[32 + 1];  // Broker权限，BOND，NCD，空=全
  xQBBestPriceListAck_c() {
    memset(m_BusinessCode, 0, sizeof(m_BusinessCode));
  };
};
// E_FID_QB_BEST_PRICE_PUSH_V2					= 50007,
// // 推送最优报价 无请求，应答同50006

//--------------------------------------------------------------------------
// E_FID_QB_BEST_PRICE_PUSH_REPAIR				= 50033,
// // 补最优报价
typedef struct xQBBestPricePushRepair_t {
  char m_company_id[4];  // 经纪公司ID',
  int m_versionfrom;     // 补的版本号开始
  int m_versionto;  // 补的版本号结束， 补的范围[versionfrom, versionto)
  xQBBestPricePushRepair_t() : m_versionfrom(0), m_versionto(0) {
    memset(m_company_id, 0, sizeof(m_company_id));
  }
} QBBestPricePushRepair_t, *PQBBestPricePushRepair_t;
// 应答同50006，

//--------------------------------------------------------------------------
// E_FID_QB_MARKET_STREAM_REQ				= 50008,
// // 请求市场动向
class xQBTradeType_c {
 public:
  char TradeType[16];  // CHG;GVN,TRD,TKN
  xQBTradeType_c() { memset(TradeType, 0, sizeof(TradeType)); }
};
typedef struct xQBMarketStreamReq_t {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
  int m_IndexFrom;  // 请求序列的开始，0 从最早开始
  int m_IndexTo;    // 请求序列的结束，-1到最新
  char m_bondkey[32 +
                 1];  // 产品ID', bondkey，如果为空则查询所有，否则查询指定券
  char m_listedmarket[8];   // 市场代码
  char m_traderId[32 + 1];  // 交易员ID
  std::list<xQBTradeType_c> m_TradeTypeList;
  char m_exDeal[2];  //""或者0表示仅应答匹配成交，1或其他表示应答全成交
  xQBMarketStreamReq_t() : m_IndexFrom(0), m_IndexTo(0) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
    memset(m_traderId, 0, sizeof(m_traderId));
    memset(m_exDeal, 0, sizeof(m_exDeal));
  }
} QBMarketStreamReq_t, *PQBMarketStreamReq_t;

struct xQBMarketStreamType1Body_c {  // MS_TYPE = 1,最优报价
 public:
  time_t m_createTime;  // 创建时间
  // char		m_bondCode[12]; //债券代码
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  char m_bondLevel[32];    // 评级
  // char		m_bondShortName[32];			//简称
  char m_bondTerm[32];        // 到期日
  char m_bidOfferId[32 + 1];  // bidOfferId
  char m_bidprice[12];        // 收益率
  char m_bid_cleanprice[12];  // 净价
  char m_bid_yield[12];       // 收益率
  char m_bidvolume[64];       // 有可能出现"40234+3212"的情况、
  char m_bidQuotetype
      [4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  // char		m_bidAgentCode[32];
  char m_ofrOfferId[32 + 1];  // ofrOfferId
  char m_ofrprice[12];        // 收益率
  char m_ofr_cleanprice[12];  // 净价
  char m_ofr_yield[12];       // 收益率
  char m_ofrvolume[64];       // 有可能出现"40234+3212"的情况、
  char m_ofrQuotetype
      [4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  // char		m_ofrAgentCode[32];
  char m_bidRebate[4];  // 是否返点(0-不返，1返点)
  char m_bidReturn_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  char m_ofrRebate[4];
  char m_ofrReturn_point[12];
  char m_bidflag_bargain[8];    // bid 可议价*',
  char m_bidflag_relation[8];   // bid OCO',
  char m_ofrflag_bargain[8];    // ofr 可议价*',
  char m_ofrflag_relation[8];   // ofr OCO',
  char m_bidExercise[2];        // 行权到期  (0-行权 1-到期)
  char m_ofrExercise[2];        // 行权到期  (0-行权 1-到期)
  char m_bid_description[128];  // 价格备注：如明天+1',
  char m_ofr_description[128];  // 价格备注：如明天+1',
  char m_bid_companyname[64];   // 买方
  char m_ofr_companyname[64];   // 卖方
  char m_bid_interpret[128];  // 拆解后的报价，格式(T+0,2000;T+1,2000;远期,2000)，Add
                              // by Lance, 2021/09/10
  char m_ofr_interpret[128];  // 拆解后的报价，格式(T+0,2000;T+1,2000;远期,2000)，Add
                              // by Lance, 2021/09/10
  bool IsBidCleanPrice() const {
    return strcmp(m_bidQuotetype, "1") == 0;
  }  // 净价
  bool IsBidFullPrice() const {
    return strcmp(m_bidQuotetype, "2") == 0;
  }  // 全价
  bool IsOfrCleanPrice() const {
    return strcmp(m_ofrQuotetype, "1") == 0;
  }  // 净价
  bool IsOfrFullPrice() const {
    return strcmp(m_ofrQuotetype, "2") == 0;
  }  // 全价
  xQBMarketStreamType1Body_c() {
    memset(this, 0, sizeof(xQBMarketStreamType1Body_c));
  };
};

struct xQBMarketStreamType2Body_c {  // MS_TYPE = 2,成交状态
 public:
  time_t m_createTime;  // 创建时间
  // char		m_bondCode[12];				//债券代码
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  // char		m_bondShortName[32];		//简称
  char m_price[12];       // 收益率
  char m_volume[64];      // 有可能出现"40234+3212"的情况、
  char m_fullPrice[12];   //
  char m_cleanPrice[12];  //
  char m_yield[12];       // 收益率
  char m_quotetype[4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  // char		m_bidAgentId[32];			//
  // char		m_bidAgentCode[32];			//
  // char		m_ofrAgentId[32];			//
  // char		m_ofrAgentCode[32];			//
  char m_rebate[4];  // 是否返点(0-不返，1返点)
  char m_return_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  char m_id[32 + 1];     // 唯一编号
  char m_dealStatus[2];  //"0 ~ 3: 客户端显示成交，		4 ~ 6:
                         //客户端删除成交"
  /*status "0: 初始化
  1: 单方确认
  2: 待审核,双方交易员确认
  3: 已完成
  4: 已作废
  5: 已撤销
  6: 删除"
  */
  char m_exercise[2];  // 行权到期  (0-行权 1-到期)
  char m_tradeMode[2];  // 交易方式: 1 = 匹配成交2 = 协商成交3 = 点击成交4 =
                        // 询价成交5 = 竞买成交//
                        // 1:匹配,2:协商,3:点击,4:询价,5:竞买
  char m_settlementType[10];  // 标准清算速度；字典值只有T+0，T+1，FWD，空值
  char m_settlementDescription[32];  // 清算速度描述,周四+0等

  bool IsCleanPrice() const { return strcmp(m_quotetype, "1") == 0; }  // 净价
  bool IsFullPrice() const { return strcmp(m_quotetype, "2") == 0; }   // 全价

  xQBMarketStreamType2Body_c() {
    memset(this, 0, sizeof(xQBMarketStreamType2Body_c));
  };
};

struct xQBMarketStreamType4Body_c {  // MS_TYPE = 4,成交状态
 public:
  time_t m_createTime;       // 创建时间
  char m_bondCode[12];       // 债券代码
  char m_bondkey[32 + 1];    // key
  char m_listedmarket[8];    // 市场代码
  char m_bondShortName[32];  // 简称
  char m_price[12];          // 收益率
  char m_volume[64];         // 有可能出现"40234+3212"的情况、
  char m_symbol[4];          // bid/ask标识',1--bid,-1,ofr
  char m_deal_status[8];  // 订单状态 \n-1：待审核 \n0：发布\n1：成交\n2：作废'
  char m_traderId[32 + 1];  // 交易员ID
  char m_rebate[4];         // 是否返点(0-不返，1返点)
  char m_return_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  xQBMarketStreamType4Body_c() {
    memset(this, 0, sizeof(xQBMarketStreamType4Body_c));
  };
};

struct xQBMarketStreamUnit_c {
 public:
  char m_company_id[4];  // 经纪公司ID',
  // char		m_company_name[64];			//经纪公司名称',
  char m_dept[32];  // 业务类型，如：Bond IRS',
  char m_type
      [5];  // 消息类型\n1：最优报价\n2：成交状态\n3：我的报价进入区间\n4：我的报价\n5：我的成交单',
  char m_operate[5];     // '消息子类',
  char m_status[5];      //,2--无效
  time_t m_modify_time;  // datetime,
  time_t m_create_time;  // datetime,
  int m_indexID;         // 报价序号，日内自增
                  //	union {
  xQBMarketStreamType1Body_c m_body1;  // MS_TYPE = 1,最优报价
  xQBMarketStreamType2Body_c m_body2;  // MS_TYPE = 2,成交状态
  //	xQBMarketStreamType4Body_c	 m_body4;
  ////MS_TYPE = 4,我的报价
  //	};
  const bool operator<(const xQBMarketStreamUnit_c& obj) const {
    time_t t1 = (m_create_time > m_modify_time ? m_create_time : m_modify_time);
    time_t t2 = (obj.m_create_time > obj.m_modify_time ? obj.m_create_time
                                                       : obj.m_modify_time);
    return t1 == t2 ? (m_indexID > obj.m_indexID) : (t1 > t2);
    // return (max(m_create_time,m_modify_time) >
    // max(obj.m_create_time,obj.m_modify_time));
  }
  xQBMarketStreamUnit_c() { memset(this, 0, sizeof(xQBMarketStreamUnit_c)); };
  const bool isSameMarketStream(const xQBMarketStreamUnit_c& obj) {
    if (strcmp(m_company_id, obj.m_company_id) != 0) return false;
    if (strcmp(m_type, obj.m_type) != 0) return false;
    if (strcmp(m_status, obj.m_status) != 0) return false;

    if (m_body1.m_createTime != obj.m_body1.m_createTime) return false;
    if (strcmp(m_body1.m_bondkey, obj.m_body1.m_bondkey) != 0) return false;
    if (strcmp(m_body1.m_listedmarket, obj.m_body1.m_listedmarket) != 0)
      return false;

    // if (strcmp(m_body1.m_bidOfferId, obj.m_body1.m_bidOfferId) != 0)return
    // false;
    if (strcmp(m_body1.m_bidprice, obj.m_body1.m_bidprice) != 0) return false;
    if (strcmp(m_body1.m_bidvolume, obj.m_body1.m_bidvolume) != 0) return false;
    if (strcmp(m_body1.m_bidRebate, obj.m_body1.m_bidRebate) != 0) return false;
    if (strcmp(m_body1.m_bidReturn_point, obj.m_body1.m_bidReturn_point) != 0)
      return false;
    if (strcmp(m_body1.m_bidflag_bargain, obj.m_body1.m_bidflag_bargain) != 0)
      return false;
    if (strcmp(m_body1.m_bidflag_relation, obj.m_body1.m_bidflag_relation) != 0)
      return false;
    if (strcmp(m_body1.m_bidExercise, obj.m_body1.m_bidExercise) != 0)
      return false;
    if (strcmp(m_body1.m_bidQuotetype, obj.m_body1.m_bidQuotetype) != 0)
      return false;
    // if (strcmp(m_body1.m_bid_description, obj.m_body1.m_bid_description) !=
    // 0)return false; if (strcmp(m_body1.m_ofrOfferId,
    // obj.m_body1.m_ofrOfferId) != 0)return false;
    if (strcmp(m_body1.m_ofrprice, obj.m_body1.m_ofrprice) != 0) return false;
    if (strcmp(m_body1.m_ofrvolume, obj.m_body1.m_ofrvolume) != 0) return false;
    if (strcmp(m_body1.m_ofrRebate, obj.m_body1.m_ofrRebate) != 0) return false;
    if (strcmp(m_body1.m_ofrReturn_point, obj.m_body1.m_ofrReturn_point) != 0)
      return false;
    if (strcmp(m_body1.m_ofrflag_bargain, obj.m_body1.m_ofrflag_bargain) != 0)
      return false;
    if (strcmp(m_body1.m_ofrflag_relation, obj.m_body1.m_ofrflag_relation) != 0)
      return false;
    if (strcmp(m_body1.m_ofrExercise, obj.m_body1.m_ofrExercise) != 0)
      return false;
    if (strcmp(m_body1.m_ofrQuotetype, obj.m_body1.m_ofrQuotetype) != 0)
      return false;
    // if (strcmp(m_body1.m_ofr_description, obj.m_body1.m_ofr_description) !=
    // 0)return false;
    return true;
  };

  const bool isSameCFETSMarketStream(const xQBMarketStreamUnit_c& obj) {
    if (strcmp(m_body1.m_bid_companyname, obj.m_body1.m_bid_companyname) != 0)
      return false;
    if (strcmp(m_body1.m_ofr_companyname, obj.m_body1.m_ofr_companyname) != 0)
      return false;
    if (strcmp(m_company_id, obj.m_company_id) != 0) return false;
    if (m_body1.m_createTime != obj.m_body1.m_createTime) return false;
    if (strcmp(m_body1.m_bondkey, obj.m_body1.m_bondkey) != 0) return false;
    if (strcmp(m_body1.m_listedmarket, obj.m_body1.m_listedmarket) != 0)
      return false;

    if (strcmp(m_body1.m_bidprice, obj.m_body1.m_bidprice) != 0) return false;
    if (strcmp(m_body1.m_bid_cleanprice, obj.m_body1.m_bid_cleanprice) != 0)
      return false;
    if (strcmp(m_body1.m_bid_yield, obj.m_body1.m_bid_yield) != 0) return false;
    if (strcmp(m_body1.m_bidvolume, obj.m_body1.m_bidvolume) != 0) return false;

    if (strcmp(m_body1.m_ofrprice, obj.m_body1.m_ofrprice) != 0) return false;
    if (strcmp(m_body1.m_ofr_cleanprice, obj.m_body1.m_ofr_cleanprice) != 0)
      return false;
    if (strcmp(m_body1.m_ofr_yield, obj.m_body1.m_ofr_yield) != 0) return false;
    if (strcmp(m_body1.m_ofrvolume, obj.m_body1.m_ofrvolume) != 0) return false;
    return true;
  };
};

class xQBMarketStreamList_c {
 public:
  std::list<xQBMarketStreamUnit_c> m_List;  // 市场动向列表数据
  char m_BusinessCode[32 + 1];  // Broker权限，BOND，NCD，空=全
  xQBMarketStreamList_c() {
    memset(m_BusinessCode, 0, sizeof(m_BusinessCode));
  };
};
// E_FID_QB_MARKET_STREAM_PUSH					= 50009,
// // 推送市场动向 无请求，应答同50008

// E_FID_QB_MODIFY_PASSWORD					= 50010,
// // 修改密码
typedef struct xQBAccountInfoMdfReq_t {
  char m_UserId[32 + 1];       // 用户id
  char m_OldPassword[32 + 1];  // 用户密码
  char m_Password[32 + 1];     // 用户密码
  char m_DisplayName[32];      // 用户显示名
  char m_Telephone[32];        // 电话
  char m_Mobile[32];           // 手机
  char m_Rm[32];               // Reuters Messager
  char m_Msn[32];              // msn
  char m_QQ[32];
  char m_Address[50];  // 地址
  xQBAccountInfoMdfReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_OldPassword, 0, sizeof(m_OldPassword));
    memset(m_Password, 0, sizeof(m_Password));
    memset(m_DisplayName, 0, sizeof(m_DisplayName));
    memset(m_Telephone, 0, sizeof(m_Telephone));
    memset(m_Mobile, 0, sizeof(m_Mobile));
    memset(m_Rm, 0, sizeof(m_Rm));
    memset(m_Msn, 0, sizeof(m_Msn));
    memset(m_QQ, 0, sizeof(m_QQ));
    memset(m_Address, 0, sizeof(m_Address));
  }
} QBAccountInfoMdfReq_t, *PQBAccountInfoMdfReq_t;
// 应答--无消息体

// E_FID_QB_QUERY_USERINFO					= 50012,
// // 查询用户信息
typedef xQBBasicRequestWithUser QBAccountInfoReq_t;
typedef struct xQBAccountInfoAck_t {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyId[32 + 1];  // 所属机构id
  char m_Password[32 + 1];   // 用户密码
  char m_DisplayName[32];    // 用户显示名
  char m_CompanyName[32];    // 所属机构
  char m_AccountType[32];    // 账号类型
  char m_ExpireDate[12];     // 账号到期日
  char m_Telephone[32];      // 电话
  char m_Mobile[32];         // 手机
  char m_Rm[32];             // Reuters Messager
  char m_Msn[32];            // msn
  char m_QQ[32];
  char m_Address[50];  // 地址
  xQBAccountInfoAck_t() { memset(this, 0, sizeof(xQBAccountInfoAck_t)); }
} QBAccountInfoAck_t, *PQBAccountInfoAck_t;

// E_FID_QB_QUERY_NEW_UERINFO_REQ = 50668,            //请求新的用户信息
// 20161219 by givins.zhu
typedef xQBBasicRequestWithUser QBAccountInfoNewReq_t;
typedef struct xQBAccountInfoNewAckUnit {
  xQBAccountInfoNewAckUnit() {
    memset(m_Type, 0, sizeof(m_Type));
    memset(m_Phone, 0, sizeof(m_Phone));
  }
  char m_Type[32];   // 类型 Mobile/Telephone
  char m_Phone[32];  // 电话
} QBAccountInfoNewAckUnit, *PQBAccountInfoNewAckUnit;

typedef struct xQBAccountInfoNewAck_t {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyId[32 + 1];  // 所属机构id
  char m_Password[32 + 1];   // 用户密码
  char m_DisplayName[32];    // 用户显示名
  char m_DisplayName_Utf8
      [32];  // 用户显示名, utf8编码;
             // 为避免显示乱码，页面显示的时候建议使用m_DisplayName_Utf8字段
  char m_UserName[64 + 1];  // 用户名
  char m_CompanyName[32];   // 所属机构
  char m_AccountType[32];   // 账号类型
  char m_ExpireDate[32];    // 账号到期日
  char m_Telephone[32];     // 电话
  char m_Mobile[32];        // 手机
  char m_Rm[32];            // Reuters Messager
  char m_Msn[32];           // msn
  char m_QQ[32];
  char m_Address[50];                              // 地址
  char m_Department[32];                           // 部门
  char m_Title[32];                                // 职位
  char m_BussinessType[64];                        // 业务类型
  char m_QQEnterprise[32];                         // 企点QQ员工号
  char m_QQEnterprise_Company[32];                 // 企点QQ机构号
  std::list<xQBAccountInfoNewAckUnit> m_lstPhone;  // 电话手机号码
  xQBAccountInfoNewAck_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_CompanyId, 0, sizeof(m_CompanyId));
    memset(m_Password, 0, sizeof(m_Password));
    memset(m_DisplayName, 0, sizeof(m_DisplayName));
    memset(m_DisplayName_Utf8, 0, sizeof(m_DisplayName_Utf8));
    memset(m_CompanyName, 0, sizeof(m_CompanyName));
    memset(m_AccountType, 0, sizeof(m_AccountType));
    memset(m_ExpireDate, 0, sizeof(m_ExpireDate));
    memset(m_Telephone, 0, sizeof(m_Telephone));
    memset(m_Mobile, 0, sizeof(m_Mobile));
    memset(m_Rm, 0, sizeof(m_Rm));
    memset(m_Msn, 0, sizeof(m_Msn));
    memset(m_QQ, 0, sizeof(m_QQ));
    memset(m_Address, 0, sizeof(m_Address));
    memset(m_Department, 0, sizeof(m_Department));
    memset(m_BussinessType, 0, sizeof(m_BussinessType));
    memset(m_UserName, 0, sizeof(m_UserName));
    memset(m_Title, 0, sizeof(m_Title));
    memset(m_QQEnterprise, 0, sizeof(m_QQEnterprise));
    memset(m_QQEnterprise_Company, 0, sizeof(m_QQEnterprise_Company));
  }
} QBAccountInfoNewAck_t, *PQBAccountInfoNewAck_t;

// E_FID_QB_USEPROTOCAL_QUERY_REQ = 50669,
// //查询用户有无同意电子使用协议，及前次同意时的名字与机构 请求
typedef xQBBasicRequestWithUser QBUseProtocolQueryReq;
// 应答，如果后台有登记过，找到最新一条相关信息，如果没有登记过，请返回空map
typedef struct xQBUseProtocolQueryAck {
  char m_UserId[32 + 1];           // uuid
  char m_UserAccount[32 + 1];      // account
  char m_UserName[32 + 1];         // 显示名
  char m_InstitutionID[32 + 1];    // CompanyID
  char m_InstitutionName[64 + 1];  // 机构名称
  xQBUseProtocolQueryAck() { memset(this, 0, sizeof(xQBUseProtocolQueryAck)); }
} QBUseProtocolQueryAck;

// E_FID_QB_USEPROTOCOL_ADD_REQ				= 50670,
// //用户同意电子使用协议 请求
typedef struct xQBUseProtocolAddReq {
  char m_UserId[32 + 1];           // uuid
  char m_UserAccount[32 + 1];      // account
  char m_UserName[32 + 1];         // 显示名
  char m_InstitutionID[32 + 1];    // CompanyID
  char m_InstitutionName[64 + 1];  // 机构名称
  char m_MACAddr[512];             // MAC地址，多个用'|'分割
  xQBUseProtocolAddReq() { memset(this, 0, sizeof(xQBUseProtocolAddReq)); }
} QBUseProtocolAddReq;
// 应答，有body，无内容，errcode=0成功， errcode!=0失败

// E_FID_QB_ISSUEREPORT_REMINDER_PUSH = 50671,
// //利率招标室，发行快报提醒注册 E_FID_QB_ISSUEREPORT_REMINDER_PUSH_CANCEL =
// 50672,			//利率招标室，发行快报提醒取消注册 注册无包体
// 推送
struct xQBIssueReportReminderAck {
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  char m_bondCode[12];     // 债券代码
  char m_shortName[32];    // 简称
  char m_AuctionType[8];  // 招标方式,DUT=荷兰式,AME=美国式,MIX=混合式
  char m_BidRate[12];     // 中标利率，"3.2568 %"，需带"%"
  char m_WeightedRate[12];  // 加权利率，"3.2568 %"，需带"%"
  char m_MarginRage[12];    // 边际利率，"3.2568 %"，需带"%"
  char m_FullMulti[12];     // 全场倍数，"3.25 倍"，需带"倍"
  char m_MarginMulti[12];   // 边际倍数，"3.25 倍"，需带"倍"
  int m_Delay;              // 提示窗口停留时长，单位秒

  xQBIssueReportReminderAck() {
    memset(this, 0, sizeof(xQBIssueReportReminderAck));
  }
};

// E_FID_QB_CREDIT_REPORT_REMINDER_PUSH = 50802,
// //信用发行社，发行快报提醒注册 E_FID_QB_CREDIT_REPORT_REMINDER_PUSH_CANCEL =
// 50803,	//信用发行社，发行快报提醒取消注册 注册无包体 推送
struct xQBCreditReportReminderAck {
  int m_reportType;  // 报告类型 0,发行结果 1,修改发行 2,取消发行
                     // 3,昨日发行结果汇总 4,当日发行结果汇总
  char m_bondkey[32 + 1];  // key			/***0,1,2使用***/
  char m_listedmarket[8];  // 市场代码		/***0,1,2使用***/
  char m_shortName[32];    // 简称			/***0,1,2使用***/
  char m_term[12];         // 期限			/***0,1,2使用***/
  char m_faceRate[12];     // 票面利率        /***0,1,2使用***/
  int m_reportCount;       // 发行结果(只)    /***3和4使用***/
  int m_Delay;             // 提示窗口停留时长，单位秒
  xQBCreditReportReminderAck() {
    memset(this, 0, sizeof(xQBCreditReportReminderAck));
    m_Delay = 5;
  }
};

// E_FID_QB_NCD_REMINDER_PUSH = 50804,			//NCD一级提醒注册
// E_FID_QB_NCD_REMINDER_PUSH_CANCEL = 50805, //NCD一级取消注册
struct xQBNCDPriReminderAck {
  char m_time[12];        // 时间 HH:MM:SS
  char m_brokerName[12];  // 经纪商
  char m_content[128];    // 提醒内容
  int m_Delay;            // 提示窗口停留时长，单位秒
  xQBNCDPriReminderAck() {
    memset(this, 0, sizeof(xQBNCDPriReminderAck));
    m_Delay = 5;
  }
};

// E_FID_QB_NCD_CASH_REMINDER_PUSH = 50806,			//NCD 资金播报
// 提醒注册 E_FID_QB_NCD_CASH__REMINDER_PUSH_CANCEL = 50807,
// //NCD 资金播报 取消注册
struct xQBNCDCashReminderAck {
  time_t m_time;        // 时间
  char m_brokerEn[12];  // 经纪商英文简称
  char m_url[128];      // 资金播报URL地址 经纪商LOGO 图片地址
  char m_content[512];  // 文本内容
  char m_title[128];    // 文本内容
  int m_img;            // 是否包含图片 0 没有， 1有
  int m_mood;           // 资金状态
  int m_Delay;          // 提示窗口停留时长，单位秒
  xQBNCDCashReminderAck() {
    memset(this, 0, sizeof(xQBNCDCashReminderAck));
    m_Delay = 5;
  }
};

// E_FID_QB_PANORAMIC_MARKET_STREAM_DEAL_REQ  = 50808,
// //请求所有broker对应的成交，全景统计页面使用
// E_FID_QB_PANORAMIC_MARKET_STREAM_DEAL_REQ_V2 = 50916, //
// 请求所有broker对应的成交，全景统计页面使用, 替换50808
struct xQBPanoramicMarketStreamUnit {
  // 应答不含有m_dealStatus判定为删除的数据，推送含有该类数据
  int m_indexID;        // 报价序号，日内自增
  time_t m_updateTime;  // 更新时间，取m_modify_time和m_create_time最大值
  char m_bondCode[12];     // 债券代码
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  char m_price[12];        // 收益率
  char m_cleanPrice[12];   // 成交对应的净价，服务端计算好
  char m_yield[12];        // 成交对应的收益率，服务端计算好
  char m_id[32 + 1];       // 唯一编号
  char m_dealStatus[2];    //"0 ~ 3: 客户端显示成交，
  char m_preCloseYield[12];  // 昨收收益率，服务端做好往前顺延的判断
  char m_preClosecleanPrice[12];  // 昨收净价，服务端做好往前顺延的判断
  char m_preAdv[12];              // 昨日平均
  char m_withinPeriodDeal
      [2];  // 是否属于20个工作日内有成交的券，'Y'为'是，''或者'N'为'否'；不足20个工作日的券不算入其中
  char m_listedFirstDeal
      [2];  // 是否属于上市后有成交的券，'Y'为'是，''或者'N'为'否'
  char m_quotetype[4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  char m_exercise[2];   // 行权到期  (0-行权 1-到期)
  char m_operate[5];    // '消息子类' 成交方向
  char m_companyId[4];  // 经纪公司ID',
  int m_Redemption_No;  // 还本方式,是否属于提前还本付息的券
  xQBPanoramicMarketStreamUnit() {
    m_Redemption_No = 0;
    m_indexID = 0;
    m_updateTime = 0;
    _InitializeString(m_bondCode);
    _InitializeString(m_bondkey);
    _InitializeString(m_listedmarket);
    _InitializeString(m_price);
    _InitializeString(m_cleanPrice);
    _InitializeString(m_yield);
    _InitializeString(m_id);
    _InitializeString(m_dealStatus);
    _InitializeString(m_preCloseYield);
    _InitializeString(m_preClosecleanPrice);
    _InitializeString(m_withinPeriodDeal);
    _InitializeString(m_listedFirstDeal);
    _InitializeString(m_quotetype);
    _InitializeString(m_exercise);
    _InitializeString(m_operate);
    _InitializeString(m_companyId);
    _InitializeString(m_preAdv);
  }
};

// 请求
struct xQBPanoramicMarketStreamDealReq {
 public:
  int m_IndexFrom;  // 请求序列的开始，0 从最早开始
  int m_IndexTo;    // 请求序列的结束，-1到最新
  xQBPanoramicMarketStreamDealReq() : m_IndexFrom(0), m_IndexTo(-1) {}
};

class xQBPanoramicMarketStreamDealAck {
 public:
  std::list<xQBPanoramicMarketStreamUnit> m_List;  //
};
// E_FID_QB_PANORAMIC_MARKET_STREAM_DEAL_PUSH = 50809,
// //bond成交推送，全景统计页面使用 推送，请求包体为空
// 应答同xQBPanoramicMarketStreamDealAck

// E_FID_QB_PANORAMIC_MARKET_STREAM_DEAL_PUSH_CACEL = 50810,
// //bond成交取消推送，全景统计页面使用
// 请求同E_FID_QB_PANORAMIC_MARKET_STREAM_DEAL_PUSH
// 无应答

// E_FID_QB_BOND_GRADE_INSTITUTION_REQ = 50812, //请求债券评级机构

class xQBBondGradeInstitutionReq {
 public:
  std::list<TW_BOND> m_List;  // 债券信息
};

class xQBBondGradeInstitutionUnit {
 public:
  char m_bondkey[32 + 1];               // key
  char m_listedmarket[8];               // 市场代码
  char m_Issuer_Rating_Current[7 + 1];  // 主体评级	bond
  char m_Rating_Current[7 + 1];         // 债项评级	bond
  char m_Issuer_Rating_Dept[64];        // 主体评级机构名称
  char m_Issuer_Rating_DeptEn[64];      // 主体评级机构英文名称
  char m_Rating_Current_Dept[64];       // 债项评级机构名称
  char m_Rating_Current_DeptEn[64];     // 债项评级机构英文名称
  xQBBondGradeInstitutionUnit() {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
    memset(m_Issuer_Rating_Current, 0, sizeof(m_Issuer_Rating_Current));
    memset(m_Rating_Current, 0, sizeof(m_Rating_Current));
    memset(m_Issuer_Rating_Dept, 0, sizeof(m_Issuer_Rating_Dept));
    memset(m_Rating_Current_Dept, 0, sizeof(m_Rating_Current_Dept));
    memset(m_Issuer_Rating_DeptEn, 0, sizeof(m_Issuer_Rating_DeptEn));
    memset(m_Rating_Current_DeptEn, 0, sizeof(m_Rating_Current_DeptEn));
  }
};

class xQBBondGradeInstitutionAck {  // 应答
 public:
  std::list<xQBBondGradeInstitutionUnit> m_List;
};

// E_FID_QB_MARKET_STREAM_HIS_QRY4				= 50135,
// // 查询单券历史报价及成交，20151207 by lance 请求
class xQBMSHistoryReqV4_c {
 public:
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  bool m_bDealOnly;        // 是否仅显示成交
  int m_nBeginDate;        // 查询开始日期
  int m_nEndDate;          // 查询结束日期
  int m_nPageIndex;        // 当前页码，从1开始
  int m_nNumPerPage;       // 每页显示条数
  int m_nPageType;         // 翻页类型 1：向前翻  2: 向后翻
  int m_nIndexID;  // 向前翻则为最前面一条价格的Id 在数据库表里价格的序列号
                   // 默认: -1
  std::list<int> m_BrokerList;  // 经纪公司列表
  xQBMSHistoryReqV4_c()
      : m_bDealOnly(0),
        m_nBeginDate(0),
        m_nEndDate(0),
        m_nPageIndex(0),
        m_nNumPerPage(0),
        m_nPageType(0),
        m_nIndexID(-1) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
  }
};

// 应答
class xQBMSHistoryAckV4_c : public xQBMarketStreamList_c {
 public:
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  bool m_bDealOnly;        // 是否仅显示成交
  int m_nBeginDate;        // 查询开始日期
  int m_nEndDate;          // 查询结束日期
  int m_nPageIndex;        // 当前页码，从1开始
  int m_nPageNum;          // 总页数
  xQBMSHistoryAckV4_c()
      : m_bDealOnly(0),
        m_nBeginDate(0),
        m_nEndDate(0),
        m_nPageIndex(0),
        m_nPageNum(0) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
  };
};

//--------------------------------------------------------
// E_FID_QB_MARKET_STREAM_EX_REQ				= 50116,
// // 查询Marketstream ,高级查询，带筛选条件
class xQBMarketStreamType_c {  // 行情类型
 public:
  char m_Type[8];  // 可选内容：CHG/TKN/GVN/TRD/MYPRICE
  xQBMarketStreamType_c() { memset(m_Type, 0, sizeof(m_Type)); }
};

class xQBMarketStreamExternalType_c {  // 债券类型
 public:
  char m_ExternalType
      [32];  ////可选内容：国债/地方债/央票/金融债/短融/中票/企业债，注意压到Message的时候需要要UTF8编码
  xQBMarketStreamExternalType_c() {
    memset(m_ExternalType, 0, sizeof(m_ExternalType));
  }
};

class xQBMarketStreamRemainTime_c {  // 剩余期限
 public:
  int m_FromDate;  // YYYYMMDD格式的起始时间，0或者不设代表过去无穷远
  int m_ToDate;  // YYYYMMDD格式的起始时间，0或者不设代表过去无穷远
  xQBMarketStreamRemainTime_c() : m_FromDate(0), m_ToDate(0) {}
};

class xQBMarketStreamRating_c {  // 评级
 public:
  char m_Rating[8];  // 可选内容：AAA/AA+/AA/AA-/A+/Others
  xQBMarketStreamRating_c() { memset(m_Rating, 0, sizeof(m_Rating)); }
};

class xQBMarketStreamGuarantee_c {  // 担保
 public:
  char m_Guarantee[4];  // 可选内容：1--有担保，0--无担保
  xQBMarketStreamGuarantee_c() { memset(m_Guarantee, 0, sizeof(m_Guarantee)); }
};

class xQBMarketStreamRateType_c {  // 利率方式
 public:
  char m_RateType[8];  // 可选内容：固息/SHIBOR/DEPO
  xQBMarketStreamRateType_c() { memset(m_RateType, 0, sizeof(m_RateType)); }
};

class xQBMarketStreamOptionType_c {  // 含权方式
 public:
  char m_OptionType[4];  // 可选内容：1--含权，0--不含权
  xQBMarketStreamOptionType_c() {
    memset(m_OptionType, 0, sizeof(m_OptionType));
  }
};

class xQBMarketStreamPublicLast_c {  // 新上市
 public:
  int m_PublicLast;  //-1代表没有设置新上市，大于等于0的值表示最近多少天上市，目前为5
  xQBMarketStreamPublicLast_c() : m_PublicLast(0) {}
};

class xQBMarketStreamMarketType_c {  // 市场级别
 public:
  char m_MarketType[3];  // 市场级别，1 --
                         // 一级半，新发债；2--二级市场，不填则所有，
  xQBMarketStreamMarketType_c() {
    memset(m_MarketType, 0, sizeof(m_MarketType));
  }
};

class xQBMarketStreamInstitutionSubtype_c {  // 企业类型
 public:
  char m_InstitutionSubtype[4];  // 企业类型，"ALL":全部 "CGE":央企 "LGE":国企
                                 // "PVE":民企 "OTE":其他 全部大写
  xQBMarketStreamInstitutionSubtype_c() {
    memset(m_InstitutionSubtype, 0, sizeof(m_InstitutionSubtype));
  }
};

class xQBFilterIssuer_c {
 public:  // 过滤器发行人
  char m_IssuerCode[7 + 1];
  xQBFilterIssuer_c() { m_IssuerCode[0] = '\0'; }
};

class xQBFilterSector_c {  // 过滤器行业
 public:
  char m_SectorCode[16 + 1];
  xQBFilterSector_c() { m_SectorCode[0] = '\0'; }
};

class xQBFilterArea_c {  // 过滤器地区
 public:
  char m_AreaCode[16 + 1];
  xQBFilterArea_c() { m_AreaCode[0] = '\0'; }
};

class xQBFilterFinanceDebt_c {  // 过滤器金融债
 public:
  char m_FinanceDebt[16 + 1];
  xQBFilterFinanceDebt_c() {
    m_FinanceDebt[0] = '\0';  // BLH中“所有”的取值
  }
};

class xQBFilterSpecial_c {  // 过滤器地区
 public:
  char m_Special[16 + 1];
  xQBFilterSpecial_c() { m_Special[0] = '\0'; }
};

typedef struct xQBMarketStreamConditionReq_t {
  int m_ReplyNum;  // 请求返回的记录数，目前默认100
  std::list<xQBTradeCmpyInfo_c> m_CmpyList;     // 经纪公司列表数据
  std::list<xQBMarketStreamType_c> m_TypeList;  // 报价类型
  std::list<xQBMarketStreamExternalType_c> m_ExternalTypeList;  // 债券类型
  std::list<xQBMarketStreamRemainTime_c> m_RemainTimeList;      // 剩余期限
  std::list<xQBMarketStreamRating_c> m_RatingList;              // 主体评级
  std::list<xQBMarketStreamGuarantee_c> m_GuaranteeList;        // 担保
  std::list<xQBMarketStreamRateType_c> m_RateTypeList;  // 特殊分类--利率方式
  std::list<xQBMarketStreamOptionType_c> m_OptionTypeList;  // 含权类型
  // Deprecated since V19
  xQBMarketStreamPublicLast_c m_NewPublic;  // 新发债
  char m_traderId[32 + 1];                  // 交易员ID
  std::list<xQBMarketStreamMarketType_c>
      m_MarketTypeList;  // 可多选，因为是List				//
  // Deprecated since V19
  char m_IsMortgage[3];  // ，"Y"表示可以，"N"表示不可以,空表示所有
  // Deprecated since V19
  char m_IsCrossMarket[3];  // ，"Y"表示可以，"N"表示不可以,空表示所有
  char m_Operate[3];  //"0": 报价变动;"1": 刷新;空或者不设置: 返回所有的
  std::list<xQBMarketStreamInstitutionSubtype_c>
      m_InstitutionSubtypeList;  // 企业类型
  char m_IsMunicipal[4];         //"Y": 城投 "N": 非城投 "ALL":全部
  std::list<xQBFilterSpecial_c>
      m_SpecialList;  // NEW_PUBLISH  NEW_ISSUER IS_MORTGAGE IS_CROSS_MKT IS_CIB
                      // IS_EXCHANGE

  // 2014/11/19 by devin.zhang:
  // V1.9版新增条件：发行人、行业、地区、金融债、债项评级；另外在债券类型中增加：NCD；
  std::list<xQBFilterIssuer_c> m_IssuerList;            // 发行人
  std::list<xQBFilterSector_c> m_SectorList;            // 行业
  std::list<xQBFilterArea_c> m_AreaList;                // 地区
  std::list<xQBMarketStreamRating_c> m_DebtRatingList;  // 债项评级
  std::list<xQBFilterFinanceDebt_c> m_FinanceDebtList;  // 金融债
  xQBMarketStreamConditionReq_t() : m_ReplyNum(0) {
    memset(m_traderId, 0, sizeof(m_traderId));
    memset(m_IsMortgage, 0, sizeof(m_IsMortgage));
    memset(m_IsCrossMarket, 0, sizeof(m_IsCrossMarket));
    memset(m_Operate, 0, sizeof(m_Operate));
    memset(m_IsMunicipal, 0, sizeof(m_IsMunicipal));
  }
} QBMarketStreamConditionReq_t, *PQBMarketStreamConditionReq_t;
// 应答同xQBMarketStreamList_c

//----------------------------------------------
// E_FID_SIGNAL 市场推送信号
struct _xSignalInfo_t {
  int market;  // 交易所
  char m_info[32];
  int reserved;    // 保留字段
  time_t curtime;  // 信号发生时间
  _xSignalInfo_t() : market(0), reserved(0), curtime(0) {
    memset(m_info, 0, sizeof(m_info));
  }
};
typedef struct _xSignalInfo_t xSignalInfo_t;

//----------------------------------------------
// E_FID_QB_MARKET_STREAM_HIS_QRY				= 50018,
// // 查询历史市场动向,根据idb的bondkey即goods_id
// E_FID_QB_MARKET_STREAM_HIS_QRY2				= 50032,
// // 查询历史市场动向 ---报价,根据sumscope的bondkey
// E_FID_QB_MARKET_STREAM_HIS_DEAL_QRY2			= 50075,
// // 查询历史市场动向,---成交，根据sumscope的bondkey tong
// E_FID_QB_MARKET_STREAM_HIS_QRY3				= 50134,
// // 查询历史市场动向---报价,根据sumscope的bondkey,anson qb_market_stream
typedef struct xQBMarketStreamHisReq_t {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据，
  time_t m_TimeBegin;                    // 查询开始时间
  time_t m_TimeEnd;                      // 查询结束时间
  char m_bondkey[32 +
                 1];  // 产品ID', bondkey，如果为空则查询所有，否则查询指定券
  char m_listedmarket[8];  // 市场代码
  int m_LastCnt;  //-1,或者不填，则取全部，其他正数则返回最近的条数
  xQBMarketStreamHisReq_t() : m_TimeBegin(0), m_TimeEnd(0), m_LastCnt(0) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
  }
} QBMarketStreamHisReq_t, *PQBMarketStreamHisReq_t;
// 应答同50008

////E_FID_QB_MARKET_STREAM_HIS_DEAL_QRY3		= 50093,
///// 查询历史市场动向,---成交--每次查询多只券，根据sumscope的bondkey tong
// typedef struct xQBMarketStreamHisListReq_t {
//	std::list<TW_BOND> m_BondList; //bondkey + market
//	std::list<xQBTradeCmpyInfo_c>	m_CmpList;
////经纪公司列表数据， 	time_t
//m_TimeBegin;					//查询开始时间 	time_t
//m_TimeEnd;						//查询结束时间 	int
//m_LastCnt;
////-1,或者不填，则取全部，其他正数则返回最近的条数
//	xQBMarketStreamHisListReq_t()
//		:m_TimeBegin(0)
//		,m_TimeEnd(0)
//		,m_LastCnt(0)
//	{}
// } QBMarketStreamHisListReq_t, *PQBMarketStreamHisListReq_t;
////应答同50008

//----------------------------------------------
// E_FID_QB_COMPANY_SORT_REQ					= 50021,
// // 设置经纪公司顺序
typedef struct xQBCompanySortReq_t {
  std::list<int> m_List;  // 经纪公司排序的列表，经纪公司ID
  char m_UserId[32 + 1];  // 用户唯一ID，非登陆账号 BF_trader_id
  int m_SaveType;  // 0表示默认值(不修正状态位，兼容旧版)，1表示保存上一次值
                   // ，2表示不保存上一次值

  xQBCompanySortReq_t() : m_SaveType(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBCompanySortReq_t, *PQBCompanySortReq_t;
// 无应答包体，通过error code 判断

////E_FID_QB_NEWS_MSG_REQ
///= 50036,				// 新闻查询
// typedef struct xQBNewsMsgReq_t {
//	int m_NewsIDFrom; //查询开始的用户ID 	char
//m_UserId[32+1];					//用户唯一ID
//	std::list<xQBTradeCmpyInfo_c>	m_List;
////经纪公司列表数据 	xQBNewsMsgReq_t() 		:m_NewsIDFrom(0)
//	{
//		memset(m_UserId, 0, sizeof(m_UserId));
//	}
// } QBNewsMsgReq_t, *PQBNewsMsgReq_t;
//
// class xQBNewsMsgInfo_c {
// public:
//	int m_NewsId;					//新闻id 	int
//m_NewsType;					//新闻类型 1.新闻 2.通知 	char
//m_NewsTitle[512];			//新标题 	char
//m_CreateBy[128];			//作者 	time_t
//m_PublishTime;				//发布时间 	char
//m_company_ids[64];			//允许的经纪公司客户。公司权限 ;
//用‘1,2,3’分割；null或‘’表示所有公司 	xQBNewsMsgInfo_c() 		:m_NewsId(0)
//		,m_NewsType(0)
//		,m_PublishTime(0)
//	{
//		memset(m_NewsTitle, 0, sizeof(m_NewsTitle));
//		memset(m_CreateBy, 0, sizeof(m_CreateBy));
//		memset(m_company_ids, 0, sizeof(m_company_ids));
//	}
// };
//
// class xQBNewsMsgListAck_c {
// public:
//	std::list<xQBNewsMsgInfo_c>		m_List;
////新闻列表数据 } ;

// E_FID_QB_NEWS_MSG_PUSH						= 50037,
// // 新闻推送 无请求，应答同50036

//----------------------------------------------
// E_FID_QB_TF_INSTRUMENT_REQ					= 50040,
// // 国债期货品种查询 无请求参数，应答如下
class xQBTFInstrument_c {
 public:
  char m_TF_Key[32 + 1];
  char m_InstrumentID[8];  // 合约代码
  xQBTFInstrument_c() {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
  }
};

class xQBTFInstrumentList_c {
 public:
  std::list<xQBTFInstrument_c> m_List;  // 国债期货列表
};

//----------------------------------------------
// E_FID_QB_TF_PRICE_REQ_V2						= 50041,
// // 国债期货行情查询
typedef struct xQBTFPriceReq_t {
  std::list<xQBTFInstrument_c> m_List;  // 国债期货列表
} QBTFPriceReq_t, *PQBTFPriceReq_t;

typedef class xQBTFPriceUnit_c {  // 国债期货快照行情
 public:
  char m_TradingDay[8 + 1];    // td		交易日
  char m_InstrumentID[8];      // iid		合约代码
  char m_ExchangeID[8];        // eid		交易所代码
  char m_ExchangeInstID[8];    // eiid		合约在交易所的代码
  float m_LastPrice;           // lp		最新价
  float m_PreSettlementPrice;  // psp		上次结算价
  float m_PreClosePrice;       // pcp		昨收盘
  double m_PreOpenInterest;    // poi		昨持仓量
  float m_OpenPrice;           // op		今开盘
  float m_HighestPrice;        // hp		最高价
  float m_LowestPrice;         // lp		最低价
  int m_Volume;                // vol		数量
  double m_Turnover;           // to		成交金额
  int m_LastVolume;            // lv		最近一笔成交的数量 -- 现量
  int m_IncrementVolume;       // iv		和前一个快照比的量差，非现量
  double m_IncrementTurnover;  // it		本次NDF_Turnover -
                               // 上次NDF_Turnover
  double m_IncrementOpenInterest;  // io		仓差
  double m_LastTurnover;    // lt		最新一笔的成交金额，(单位元)
  double m_OpenInterest;    // oi		持仓量
  float m_ClosePrice;       // cp		今收盘
  float m_SettlementPrice;  // sp		本次结算价
  float m_UpperLimitPrice;  // ulp		涨停板价
  float m_LowerLimitPrice;  // llp		跌停板价
  float m_CurrDelta;        // cd		今虚实度
  float m_PreDelta;         // pd		昨虚实度
  char m_UpdateTime[24];    // ut		最后修改时间(HH:MM:SS)
  int m_UpdateMillisec;     // um		最后修改毫秒
  float m_AveragePrice;     // ap		当日均价
  float m_BidPrice1;        // bp1		申买价一
  int m_BidVolume1;         // bv1		申买量一
  float m_AskPrice1;        // ap1		申卖价一
  int m_AskVolume1;         // av1		申卖量一
  float m_BidPrice2;        // bp2		申买价二
  int m_BidVolume2;         // bv2		申买量二
  float m_AskPrice2;        // ap2		申卖价二
  int m_AskVolume2;         // bv2		申卖量二
  float m_BidPrice3;        // bp3		申买价三
  int m_BidVolume3;         // bv3		申买量三
  float m_AskPrice3;        // ap3		申卖价三
  int m_AskVolume3;         // av3		申卖量三
  float m_BidPrice4;        // bp4		申买价四
  int m_BidVolume4;         // bv4		申买量四
  float m_AskPrice4;        // ap4		申卖价四
  int m_AskVolume4;         // av4		申卖量四
  float m_BidPrice5;        // bp5		申买价五
  int m_BidVolume5;         // bv5		申买量五
  float m_AskPrice5;        // ap5		申卖价五
  int m_AskVolume5;         // av5		申卖量五
  bool m_IsHoliday;         // ih		是否是节假日true是holiday
                     // false不是holiday
  xQBTFPriceUnit_c()
      : m_LastPrice(0),
        m_PreSettlementPrice(0),
        m_PreClosePrice(0),
        m_PreOpenInterest(0),
        m_OpenPrice(0),
        m_HighestPrice(0),
        m_LowestPrice(0),
        m_Volume(0),
        m_Turnover(0),
        m_LastVolume(0),
        m_IncrementVolume(0),
        m_IncrementTurnover(0),
        m_IncrementOpenInterest(0),
        m_LastTurnover(0),
        m_OpenInterest(0),
        m_ClosePrice(0),
        m_SettlementPrice(0),
        m_UpperLimitPrice(0),
        m_LowerLimitPrice(0),
        m_CurrDelta(0),
        m_PreDelta(0),
        m_UpdateMillisec(0),
        m_AveragePrice(0),
        m_BidPrice1(0),
        m_BidVolume1(0),
        m_AskPrice1(0),
        m_AskVolume1(0),
        m_BidPrice2(0),
        m_BidVolume2(0),
        m_AskPrice2(0),
        m_AskVolume2(0),
        m_BidPrice3(0),
        m_BidVolume3(0),
        m_AskPrice3(0),
        m_AskVolume3(0),
        m_BidPrice4(0),
        m_BidVolume4(0),
        m_AskPrice4(0),
        m_AskVolume4(0),
        m_BidPrice5(0),
        m_BidVolume5(0),
        m_AskPrice5(0),
        m_AskVolume5(0),
        m_IsHoliday(false) {
    memset(m_TradingDay, 0, sizeof(m_TradingDay));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
    memset(m_ExchangeID, 0, sizeof(m_ExchangeID));
    memset(m_ExchangeInstID, 0, sizeof(m_ExchangeInstID));
    memset(m_UpdateTime, 0, sizeof(m_UpdateTime));
  }
} QBTFPriceInfo;

class xQBTFPriceList_c {
 public:
  std::list<xQBTFPriceUnit_c> m_List;  // 国债期货列表
};

// E_FID_QB_TF_PRICE_FIVE_REQ = 50925, //	 国债期货5档行情查询
// E_FID_QB_TF_PRICE_FIVE_PUSH = 50926,
// //国债期货5档行情推送
typedef class xQBTFPriceFiveUnit_c {  // 国债期货快照行情
 public:
  char m_InstrumentID[8];      // iid		合约代码
  float m_PreSettlementPrice;  // psp		上次结算价
  float m_BidPrice1;           // bp1		申买价一
  int m_BidVolume1;            // bv1		申买量一
  int m_BidVolume1Incre;       // bv1Ic		申买量一 变动
  float m_AskPrice1;           // ap1		申卖价一
  int m_AskVolume1;            // av1		申卖量一
  int m_AskVolume1Incre;       // av1Ic		申卖量一 变动
  float m_BidPrice2;           // bp2Ic		申买价二
  int m_BidVolume2;            // bv2		申买量二
  int m_BidVolume2Incre;       // bv2Ic		申买量二 变动
  float m_AskPrice2;           // ap2		申卖价二
  int m_AskVolume2;            // bv2		申卖量二
  int m_AskVolume2Incre;       // bv2Ic		申卖量二 变动
  float m_BidPrice3;           // bp3		申买价三
  int m_BidVolume3;            // bv3		申买量三
  int m_BidVolume3Incre;       // bv3Ic		申买量三 变动
  float m_AskPrice3;           // ap3		申卖价三
  int m_AskVolume3;            // av3		申卖量三
  int m_AskVolume3Incre;       // av3Ic		申卖量三 变动
  float m_BidPrice4;           // bp4		申买价四
  int m_BidVolume4;            // bv4		申买量四
  int m_BidVolume4Incre;       // bv4Ic		申买量四 变动
  float m_AskPrice4;           // ap4		申卖价四
  int m_AskVolume4;            // av4		申卖量四
  int m_AskVolume4Incre;       // av4Ic		申卖量四 变动
  float m_BidPrice5;           // bp5		申买价五
  int m_BidVolume5;            // bv5		申买量五
  int m_BidVolume5Incre;       // bv5Ic		申买量五 变动
  float m_AskPrice5;           // ap5		申卖价五
  int m_AskVolume5;            // av5		申卖量五
  int m_AskVolume5Incre;       // av5Ic		申卖量五 变动
  char m_UpdateTime[24];       // ut		最后修改时间(HH:MM:SS)
  int m_UpdateMillisec;        // um		最后修改毫秒

  xQBTFPriceFiveUnit_c()
      : m_PreSettlementPrice(0),
        m_UpdateMillisec(0),
        m_BidPrice1(0),
        m_BidVolume1(0),
        m_AskPrice1(0),
        m_AskVolume1(0),
        m_BidPrice2(0),
        m_BidVolume2(0),
        m_AskPrice2(0),
        m_AskVolume2(0),
        m_BidPrice3(0),
        m_BidVolume3(0),
        m_AskPrice3(0),
        m_AskVolume3(0),
        m_BidPrice4(0),
        m_BidVolume4(0),
        m_AskPrice4(0),
        m_AskVolume4(0),
        m_BidPrice5(0),
        m_BidVolume5(0),
        m_AskPrice5(0),
        m_AskVolume5(0),
        m_BidVolume1Incre(0),
        m_AskVolume1Incre(0),
        m_BidVolume2Incre(0),
        m_AskVolume2Incre(0),
        m_BidVolume3Incre(0),
        m_AskVolume3Incre(0),
        m_BidVolume4Incre(0),
        m_AskVolume4Incre(0),
        m_BidVolume5Incre(0),
        m_AskVolume5Incre(0) {
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
    memset(m_UpdateTime, 0, sizeof(m_UpdateTime));
  }
} QBTFPriceFiveInfo;

class xQBTFPriceFiveList_c {
 public:
  std::list<xQBTFPriceFiveUnit_c> m_List;  // 国债期货5档行情列表
};

//----------------------------------------------
// E_FID_QB_TF_PRICE_PUSH_V3						= 50042,
// // 国债期货行情推送
////请求包同E_FID_QB_TF_PRICE_REQ_V2，应答同E_FID_QB_TF_PRICE_REQ_V2

// E_FID_QB_TF_PRICE_PUSH_MINI = 50923,
// //国债期货行情精简版推送注册
typedef class xQBTFPriceMiniUnit_c {  // 国债期货快照行情
 public:
  char m_TFID[8];     //		合约代码
  float m_LastPrice;  //		最新价
  float m_PrePrice;   //		上次结算价
  char m_UpTime[12];  //		最后修改时间(HH:MM:SS)
  xQBTFPriceMiniUnit_c() : m_LastPrice(0), m_PrePrice(0) {
    memset(m_TFID, 0, sizeof(m_TFID));
    memset(m_UpTime, 0, sizeof(m_UpTime));
  }
} QBTFMiniPriceInfo;

class xQBTFPriceList_Mini_c {
 public:
  std::list<xQBTFPriceMiniUnit_c> m_List;  // 国债期货精简版列表
};

// E_FID_QB_TF_SETTLEMENT_ESTIMATE_REQ			= 50247,
// //查询估结算 请求包同E_FID_QB_TF_PRICE_REQ_V2， 应答
class xQBTFSettlementEstimateUnit_c {  // 国债期货估结算行情
 public:
  char m_TradingDay[8 + 1];       //	交易日
  char m_InstrumentID[8];         //	合约代码
  char m_SettlementEstimate[16];  //	估结算
  xQBTFSettlementEstimateUnit_c() {
    memset(m_TradingDay, 0, sizeof(m_TradingDay));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
    memset(m_SettlementEstimate, 0, sizeof(m_SettlementEstimate));
  }
};

class xQBTFSettlementEstimateList_c {
 public:
  std::list<xQBTFSettlementEstimateUnit_c> m_List;  // 国债期货估结算列表
};
// E_FID_QB_TF_SETTLEMENT_ESTIMATE_NEW_REG			= 50248,
// //注册估结算推送 请求应答同 E_FID_QB_TF_SETTLEMENT_ESTIMATE_REQ 50247

// E_FID_QB_TF_ALL_CONTACT_INFO_REQ = 50251
// 国债期货查询所有合约，含过期合约，历史价差页面使用 Req为空
class xQBTFContactInfoReq_c {
 public:
  char m_Version[16];  // 版本号，如果为空，则使用老版本（不包含2年期合约），
  xQBTFContactInfoReq_c() { memset(m_Version, 0, sizeof(m_Version)); }
};
//
class xQBTFAllContractInfo_c {
 public:
  char m_TF_Key[32 + 1];  // 合约的key
  char m_TF_ID[8];        // 合约代码
  UINT m_Delivery_Date;   // 2.8新增，合约交割日
  const bool operator<(const xQBTFAllContractInfo_c& obj) const {
    return strcmp(m_TF_ID, obj.m_TF_ID) > 0;
  }
  xQBTFAllContractInfo_c() : m_Delivery_Date(0) {
    _InitializeString(m_TF_Key);
    _InitializeString(m_TF_ID);
  }
};

class xQBTFAllContractInfoAck_c {
 public:
  std::list<xQBTFAllContractInfo_c> m_List;
};

//----------------------------------------------
// E_FID_QB_TF_CONTACT_INFO_REQ				= 50043,
// // 国债期货合约基本信息  tong
typedef struct xQBTFContactInfoReq_t {
  std::list<xQBTFInstrument_c> m_List;  // 如果为空这查询所有合约
  char m_Version[16];  // 版本号，如果为空，则使用老版本（不包含2年期合约），
  xQBTFContactInfoReq_t() { memset(m_Version, 0, sizeof(m_Version)); };
} QBTFContactInfoReq_t, *PQBTFContactInfoReq_t;

class xQBTFContactInfo_c {
 public:
  char m_TF_Key[32 + 1];    // 合约的key
  char m_TF_ID[8];          // 合约代码
  char m_TF_ShortName[32];  // 合约简称
  int m_Delivery_Month;
  UINT m_Last_Trading_Day;
  UINT m_Delivery_Date;
  UINT m_BondTerm;
  UINT m_Deliverable_maturity_Start;
  UINT m_Deliverable_maturity_End;
  char m_Quoted_Way[16];
  float m_Min_Change;
  char m_Trading_Time[32];
  char m_Last_Day_Trading_Time[32];
  float m_Price_Limit;
  float m_Lowest_Margins;
  char m_Delivery_Way[16];
  char m_Listed_Market[32];
  char m_Is_Tradable[2];  //'Y'--可交易，“N”--不可交易
  xQBTFContactInfo_c()
      : m_Delivery_Month(0),
        m_Last_Trading_Day(0),
        m_Delivery_Date(0),
        m_BondTerm(0),
        m_Deliverable_maturity_Start(0),
        m_Deliverable_maturity_End(0),
        m_Min_Change(0),
        m_Price_Limit(0),
        m_Lowest_Margins(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
    memset(m_TF_ShortName, 0, sizeof(m_TF_ShortName));
    memset(m_Quoted_Way, 0, sizeof(m_Quoted_Way));
    memset(m_Trading_Time, 0, sizeof(m_Trading_Time));
    memset(m_Last_Day_Trading_Time, 0, sizeof(m_Last_Day_Trading_Time));
    memset(m_Delivery_Way, 0, sizeof(m_Delivery_Way));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Is_Tradable, 0, sizeof(m_Is_Tradable));
  }
};

class xQBTFContactInfoList_c {
 public:
  std::list<xQBTFContactInfo_c> m_List;

  UINT m_NatChangeDate;  //  返回国债期货开收盘变更开始时间   add by givins.zhu
                         //  20200426

  xQBTFContactInfoList_c() : m_NatChangeDate(0) {}
};

//----------------------------------------------
// E_FID_QB_TF_REFBOND_REQ						= 50044,
// // 请求国债期货相关的现券 tong
typedef struct xQBRefBondReq_t {
  char m_TF_Key[32 + 1];
  xQBRefBondReq_t() { memset(m_TF_Key, 0, sizeof(m_TF_Key)); }
} QBRefBondReq_t, *PQBRefBondReq_t;

class xQBRefBond_c {
 public:
  char m_TF_Key[32 + 1];      // 国债期货编码	TF_Fundamental
  char m_TF_ID[8];            // 期货代码	TF_Fundamental
  char m_Bond_Key[32 + 1];    // 可交割国债编码	TF_Conversion_Factor
  float m_Conversion_Factor;  // 转换因子
  xQBRefBond_c() : m_Conversion_Factor(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
  }
};

class xQBRefBondList_c {
 public:
  std::list<xQBRefBond_c> m_List;
};

//----------------------------------------------
// E_FID_QB_TF_PRICE_REGISTER					= 50045,
// // 国债期货行情注册
////请求包同E_FID_QB_TF_PRICE_REQ_V2， 无应答包体

//----------------------------------------------
// E_FID_QB_TF_PRICE_PUSH_CANCEL_V3				= 50046,
// // 国债期货行情取消注册
////请求包同E_FID_QB_TF_PRICE_REQ_V2， 无应答包体

//----------------------------------------------
// E_FID_QB_TF_REALTIME					= 50047,
// // 国债期货分时行情查询
typedef struct xQBTFRealTimeReq_t {
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_beginTime;  // 设置开始时间，如果不设，或者设置0，都代表当天的最早
  time_t m_endTime;  // 设置结束时间，如果不设，或者设置0，都代表当天的最晚,时间区间的数学表达式(beginTime,
                     // endTime]
  xQBTFRealTimeReq_t() : m_beginTime(0), m_endTime(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
} QBTFRealTimeReq_t, *PQBTFRealTimeReq_t;

class xQBTFRealTimeUnit_c {
 public:
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_Tran_Time;     // 成交时间
  int m_Tran_Time_Msec;   // 成交时的秒值，存在同一秒有多比交易
  float m_Open;           // 开盘
  float m_High;           // 最高
  float m_Low;            // 最低
  float m_Close;          // 收盘
  double m_Positions;     // 持仓量
  double m_Volume;        // 成交量
  double m_Volume_Total;  // 总成交量
  double m_Amount_Total;  // 总成交额
  double m_BidPrice1;     //	申买价一
  int m_BidVolume1;       //	申买量一
  double m_AskPrice1;     //	申卖价一
  int m_AskVolume1;       //	申卖量一

  xQBTFRealTimeUnit_c()
      : m_Tran_Time(0),
        m_Tran_Time_Msec(0),
        m_Open(0),
        m_High(0),
        m_Low(0),
        m_Close(0),
        m_Positions(0),
        m_Volume(0),
        m_Volume_Total(0),
        m_Amount_Total(0),
        m_BidPrice1(0),
        m_BidVolume1(0),
        m_AskPrice1(0),
        m_AskVolume1(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
};

class xQBTFRealTimeList_c {
 public:
  std::list<xQBTFRealTimeUnit_c> m_List;  // 分时行情列表
};

//----------------------------------------------
// E_FID_QB_TF_KLINE_MINUTE5	= 50048,			//
// 国债期货5分钟K线数据查询 E_FID_QB_TF_KLINE_MINUTE5_V2 = 50175,
// // 国债期货，过期合约，5分钟K线数据查询，V3.5，added by Lance
typedef struct xQBTFMinuteReq_t {
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_beginTime;  // 设置开始时间，如果不设，或者设置0，都代表无穷早
  time_t m_endTime;  // 设置结束时间，如果不设，或者设置0，都代表现在,时间区间的数学表达式(beginTime,
                     // endTime]
  int m_limitCount;  // 记录数量，代表离endTime最近的limit条记录，不设置或者设置-1，表示所有
  xQBTFMinuteReq_t() : m_beginTime(0), m_endTime(0), m_limitCount(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
} QBTFMinuteReq_t, *PQBTFMinuteReq_t;

class xQBTFMinuteUnit_c {
 public:
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_Tran_Time;     // 成交时间
  int m_Tran_Time_Msec;   // 成交时的秒值，存在同一秒有多比交易
  float m_Open;           // 开盘
  float m_High;           // 最高
  float m_Low;            // 最低
  float m_Close;          // 收盘
  double m_Volume;        // 成交量 手	每个K线周期内总的成交量
  double m_Amount;        // 成交额 百元	每个K线周期内总的成交额
  double m_Positions;     // 持仓量
  double m_Volume_Total;  // 总成交量
  double m_Amount_Total;  // 总成交额
  xQBTFMinuteUnit_c()
      : m_Tran_Time(0),
        m_Tran_Time_Msec(0),
        m_Open(0),
        m_High(0),
        m_Low(0),
        m_Close(0),
        m_Volume(0),
        m_Amount(0),
        m_Positions(0),
        m_Volume_Total(0),
        m_Amount_Total(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
};

class xQBTFMinuteList_c {
 public:
  std::list<xQBTFMinuteUnit_c> m_List;  // 分钟行情列表
};

//----------------------------------------------
// E_FID_QB_TF_KLINE_DAY						= 50049,
// // 国债期货日K线数据查询 E_FID_QB_TF_KLINE_WEEK
// = 50055,			// 国债期货周K线数据查询 E_FID_QB_TF_KLINE_MONTH
// = 50056,			// 国债期货月K线数据查询 E_FID_QB_TF_KLINE_YEAR
// = 50057,			// 国债期货年K线数据查询
// E_FID_QB_TF_KLINE_DAY_V2					= 50176,
// // 国债期货，过期合约，日K线数据查询 E_FID_QB_TF_KLINE_WEEK_V2
// = 50177,			// 国债期货，过期合约，周K线数据查询
// E_FID_QB_TF_KLINE_MONTH_V2				= 50178,
// // 国债期货，过期合约，月K线数据查询 E_FID_QB_TF_KLINE_YEAR_V2
// = 50179,			// 国债期货，过期合约，年K线数据查询
typedef struct xQBTFHisKlineReq_t {
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_beginTime;  // 设置开始时间，如果不设，或者设置0，都代表无穷早
  time_t m_endTime;  // 设置结束时间，如果不设，或者设置0，都代表现在,时间区间的数学表达式(beginTime,
                     // endTime]
  int m_limitCount;  // 记录数量，代表离endTime最近的limit条记录，不设置或者设置-1，表示所有
  xQBTFHisKlineReq_t() : m_beginTime(0), m_endTime(0), m_limitCount(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
} QBTFHisKlineReq_t, *PQBTFHisKlineReq_t;

class xQBTFHisKlineUnit_c {
 public:
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_Tran_Time;     // 成交时间
  int m_Tran_Time_Msec;   // 成交时的秒值，存在同一秒有多比交易
  float m_Open;           // 开盘
  float m_High;           // 最高
  float m_Low;            // 最低
  float m_Close;          // 收盘
  double m_Volume;        // 成交量 手	每个K线周期内总的成交量
  double m_Amount;        // 成交额 百元	每个K线周期内总的成交额
  double m_Positions;     // 持仓量
  float m_Pre_Close;      // 昨收盘	Double	元	上一个交易日的收盘价
  float m_Pre_Settlement_Price;  // 昨结算	Double	元
                                 // 上一个交易日的结算价
  float m_Settlement_Price;  // 结算	Double	元
  xQBTFHisKlineUnit_c()
      : m_Tran_Time(0),
        m_Tran_Time_Msec(0),
        m_Open(0),
        m_High(0),
        m_Low(0),
        m_Close(0),
        m_Volume(0),
        m_Amount(0),
        m_Positions(0),
        m_Pre_Close(0),
        m_Pre_Settlement_Price(0),
        m_Settlement_Price(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
  bool operator<(const xQBTFHisKlineUnit_c& obj) const {
    if (m_Tran_Time == obj.m_Tran_Time)
      return m_Tran_Time_Msec < obj.m_Tran_Time_Msec;
    else
      return m_Tran_Time < obj.m_Tran_Time;
  }
};

class xQBTFHisKlineList_c {
 public:
  std::list<xQBTFHisKlineUnit_c> m_List;  // K线行情列表
};

//----------------------------------------------
// E_FID_QB_TF_ALL_KLINE_DAY_REQ             = 50252
// //国债期货所有合约（包含过期合约）日K线数据查询 请求结构同50049

class xQBTFAllHisKlineUnit_c {
 public:
  char m_TF_Key[32 + 1];      // 国债期货编码
  char m_TF_ID[8];            // 期货代码
  time_t m_Tran_Time;         // 成交时间
  double m_Settlement_Price;  // 结算	Double	元
  double m_Volume;     // 成交量 手	每个K线周期内总的成交量
  double m_Positions;  // 持仓量
  xQBTFAllHisKlineUnit_c()
      : m_Tran_Time(0), m_Settlement_Price(0), m_Volume(0), m_Positions(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
  bool operator<(const xQBTFAllHisKlineUnit_c& obj) const {
    return m_Tran_Time < obj.m_Tran_Time;
  }
};

class xQBTFAllHisKlineAck_c {
 public:
  std::list<xQBTFAllHisKlineUnit_c> m_List;  // 日线行情列表
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_ISSUE					= 50050,
// // 交易提示--发行流通
typedef struct xQBBondTradeTipReq_t {
  UINT m_BeginDate;  // 查询开始日期
  UINT m_EndDate;    // 查询结束日期
  int m_Separate;    // 0表示不分包，1表示分包  add by ke.li 20150911
  xQBBondTradeTipReq_t() : m_BeginDate(0), m_EndDate(0), m_Separate(0) {}
} QBBondTradeTipReq_t, *PQBBondTradeTipReq_t;

class xQBBondTradeTipIssueInfo_c {  // 发行流通
 public:
  char m_BondKey[32 + 1];                    // bondKey;				唯一
  char m_BondID[12];                         // bond ID、bond code;
  char m_Event_Code[10];                     // 事件
  char m_Short_Name[32 + 1];                 // 简称
  char m_Sub_Event_Code[10];                 // 增续发次序
  char m_Listed_Market[SELECTIVE_CODE_LEN];  // 交易市场
  char m_Bond_Subtype[SELECTIVE_CODE_LEN];   // 类别
  UINT m_Issue_Start_Date;                   // 发行日
  UINT m_Interest_Start_Date;                // 起息日
  UINT m_Dist_Date_Start;                    // 分销起始日
  UINT m_Dist_Date_End;                      // 分销结束日
  UINT m_StartDate;                          // 事件起始日期，p_reminder
  UINT m_EndDate;                            // 事件结束日期，p_reminder
  xQBBondTradeTipIssueInfo_c()
      : m_Issue_Start_Date(0),
        m_Interest_Start_Date(0),
        m_Dist_Date_Start(0),
        m_Dist_Date_End(0),
        m_StartDate(0),
        m_EndDate(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Event_Code, 0, sizeof(m_Event_Code));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Sub_Event_Code, 0, sizeof(m_Sub_Event_Code));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Bond_Subtype, 0, sizeof(m_Bond_Subtype));
  }
};

class xQBBondTradeTipIssueInfoList_c {
 public:
  std::list<xQBBondTradeTipIssueInfo_c> m_List;  //
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_MATURITY					= 50051,
// // 交易提示--付息兑付 请求结构同50050
class xQBBondTradeTipMaturityInfo_c {  // 付息兑付
 public:
  char m_BondKey[32 + 1];                       // bondKey;				唯一
  char m_BondID[12];                            // bond ID、bond code;
  UINT m_Payment_Date;                          // 付息日期
  float m_Principal;                            // 兑付本金
  float m_Remaining;                            // 票面余额
  char m_Short_Name[32 + 1];                    // 简称
  char m_Short_Name_En[64];                     // 简称-英文
  char m_Listed_Market[SELECTIVE_CODE_LEN];     // 交易市场
  float m_Coupon_Rate_Current;                  // 最新票面利率
  char m_Coupon_Frequency[SELECTIVE_CODE_LEN];  // 付息频率
  float m_Interest;                             // 本期付息
  UINT m_Next_Payment_Date;                     // 下期付息日
  float m_Next_Coupon_Rate_Current;             // 下期票面利率
  xQBBondTradeTipMaturityInfo_c()
      : m_Payment_Date(0),
        m_Principal(0),
        m_Remaining(0),
        m_Coupon_Rate_Current(0),
        m_Interest(0),
        m_Next_Payment_Date(0),
        m_Next_Coupon_Rate_Current(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Coupon_Frequency, 0, sizeof(m_Coupon_Frequency));
  }
};

class xQBBondTradeTipMaturityInfoList_c {
 public:
  std::list<xQBBondTradeTipMaturityInfo_c> m_List;  //
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_OPTION_EXERCISE			= 50052,
// // 交易提示--行权提示 请求结构同50050
class xQBBondTradeTipOptionExerciseInfo_c {  // 行权提示
 public:
  char m_BondKey[32 + 1];                    // bondKey;				唯一
  char m_BondID[12];                         // bond ID、bond code;
  char m_Event_Code[10];                     // 事件
  char m_Short_Name[32 + 1];                 // 简称
  char m_Short_Name_En[64];                  // 简称-英文
  char m_Listed_Market[SELECTIVE_CODE_LEN];  // 交易市场
  UINT m_Interest_Start_Date;                // 起息日
  UINT m_Option_Date;                        // 行权日
  UINT m_Maturity_Date;                      // 到期日
  char m_Option_Record_Date[24];             // 登记起始日|登记到期日
  char m_Option_Price_Ratio[10];             // 行权价格
  UINT m_StartDate;                          // 事件起始日期，p_reminder
  UINT m_EndDate;                            // 事件结束日期，p_reminder
  xQBBondTradeTipOptionExerciseInfo_c()
      : m_Interest_Start_Date(0),
        m_Option_Date(0),
        m_Maturity_Date(0),
        m_StartDate(0),
        m_EndDate(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Event_Code, 0, sizeof(m_Event_Code));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Option_Record_Date, 0, sizeof(m_Option_Record_Date));
    memset(m_Option_Price_Ratio, 0, sizeof(m_Option_Price_Ratio));
  }
};

class xQBBondTradeTipOptionExerciseInfoList_c {
 public:
  std::list<xQBBondTradeTipOptionExerciseInfo_c> m_List;  //
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_RATING_MODIFY			= 50053,
// // 交易提示--评级修正 请求结构同50050
class xQBBondTradeTipRatingModifyInfo_c {  // 评级修正
 public:
  char m_BondKey[32 + 1];                    // bondKey;				唯一
  char m_BondID[12];                         // bond ID、bond code;
  char m_Event_Code[10];                     // 事件
  char m_Short_Name[32 + 1];                 // 简称
  char m_Short_Name_En[64];                  // 简称-英文
  char m_Listed_Market[SELECTIVE_CODE_LEN];  // 交易市场
  char m_Issuer_Rating_Current[7 + 1];       // 主体评级	bond
  char m_P_Issuer_Rating_Current[7 + 1];     // 上次主体评级	bond
  UINT m_P_Issuer_Rating_Date;               // 上次主体评级时间
  char m_Rating_Current[7 + 1];              // 债项评级
  char m_P_Rating_Current[7 + 1];            // 上次债项评级
  UINT m_P_Rating_Date;                      // 上次债项评级时间
  char m_Institution_Short_Name_C[64];       // 评级机构
  UINT m_StartDate;                          // 事件起始日期，p_reminder
  UINT m_EndDate;                            // 事件结束日期，p_reminder
  xQBBondTradeTipRatingModifyInfo_c()
      : m_P_Issuer_Rating_Date(0),
        m_P_Rating_Date(0),
        m_StartDate(0),
        m_EndDate(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Event_Code, 0, sizeof(m_Event_Code));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Short_Name_En, 0, sizeof(m_Short_Name_En));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_Issuer_Rating_Current, 0, sizeof(m_Issuer_Rating_Current));
    memset(m_P_Issuer_Rating_Current, 0, sizeof(m_P_Issuer_Rating_Current));
    memset(m_Rating_Current, 0, sizeof(m_Rating_Current));
    memset(m_P_Rating_Current, 0, sizeof(m_P_Rating_Current));
    memset(m_Institution_Short_Name_C, 0, sizeof(m_Institution_Short_Name_C));
  }
};

class xQBBondTradeTipRatingModifyInfoList_c {
 public:
  std::list<xQBBondTradeTipRatingModifyInfo_c> m_List;  //
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_ISSUE_V5					= 50110,
// // 交易提示--发行流通_V5	tong
typedef struct xQBBondTradeTipV5Req_t {
  std::list<UINT> m_DateList;  // 查询的日期列表YYYYMMDD
} QBBondTradeTipV5Req_t, *PQBBondTradeTipV5Req_t;

class xQBBondTradeTipIssueInfoV5_c {  // 发行流通
 public:
  char m_BondKey[32 + 1];               // bondKey;				唯一
  char m_BondID[12];                    // bond ID、bond code;
  char m_Event_Code[10];                // 事件
  char m_Short_Name[32 + 1];            // 简称
  char m_Short_Name_En[64];             // 简称-英文
  char m_Issuer_Rating_Current[7 + 1];  // 主体评级	bond
  char m_Rating_Current[7 + 1];         // 债项评级	bond
  int m_Maturity_Term;                  // 偿还期限
  char m_Maturity_Term_News[8];
  char m_Option_type[8];                        // 含权结构 5+6
  char m_Term_Unit[SELECTIVE_CODE_LEN];         // ，两字段合并显示;
  char m_Sub_Event_Code[10];                    // 增续发次序
  char m_Listed_Market[SELECTIVE_CODE_LEN];     // 交易市场
  char m_Bond_Subtype[SELECTIVE_CODE_LEN];      // 类别
  UINT m_Issue_Start_Date;                      // 发行日
  UINT m_Interest_Start_Date;                   // 起息日
  UINT m_Maturity_Date;                         // 到期日	bond
  UINT m_Dist_Date_Start;                       // 分销起始日
  UINT m_Dist_Date_End;                         // 分销结束日
  UINT m_Payment_Date;                          // 缴款日
  double m_Planned_Issue_Amount;                // 计划发行量
  double m_Issue_Amount;                        // 流通规模
  float m_Coupon_Rate_Current;                  // 票面利率(%)	bond
  char m_Coupon_Type[SELECTIVE_CODE_LEN];       // 利率方式
  int m_Fixing_MA_Days;                         // 利率平均天期
  char m_FRN_Index_ID[16 + 1];                  // 基础利率代码
  float m_Coupon_Rate_Spread;                   // 利差(%)
  float m_Subscription_Ratio;                   // 招标倍数
  char m_Coupon_Frequency[SELECTIVE_CODE_LEN];  // 付息频率
  char m_Underwriter_Name
      [256];  // 主承销商
              // (同一债券若有多条记录,用';'隔开显示)P_underwriter_info
  std::list<xInstitutionUnit_c> m_VenderList;  // 主承
  std::list<xInstitutionUnit_c> m_DistList;    // 分销商
  UINT m_Auction_Date_Start;                   // 招标/建档日
  UINT m_Listed_Date;                          // 上市日	bond
  UINT m_Delisted_Date;                        // 下市日
  UINT m_StartDate;  // 事件起始日期，p_reminder
  UINT m_EndDate;    // 事件结束日期，p_reminder
  xQBBondTradeTipIssueInfoV5_c()
      : m_Maturity_Term(0),
        m_Issue_Start_Date(0),
        m_Interest_Start_Date(0),
        m_Maturity_Date(0),
        m_Dist_Date_Start(0),
        m_Dist_Date_End(0),
        m_Payment_Date(0),
        m_Planned_Issue_Amount(0),
        m_Issue_Amount(0),
        m_Coupon_Rate_Current(0),
        m_Subscription_Ratio(0),
        m_Fixing_MA_Days(0),
        m_Coupon_Rate_Spread(0),
        m_Auction_Date_Start(0),
        m_Listed_Date(0),
        m_Delisted_Date(0),
        m_StartDate(0),
        m_EndDate(0) {
    m_BondKey[0] = '\0';
    m_BondID[0] = '\0';
    m_Event_Code[0] = '\0';
    m_Short_Name[0] = '\0';
    m_Short_Name_En[0] = '\0';
    m_Issuer_Rating_Current[0] = '\0';
    m_Rating_Current[0] = '\0';
    m_Term_Unit[0] = '\0';
    m_Sub_Event_Code[0] = '\0';
    m_Listed_Market[0] = '\0';
    m_Bond_Subtype[0] = '\0';
    m_Coupon_Type[0] = '\0';
    m_FRN_Index_ID[0] = '\0';
    m_Coupon_Frequency[0] = '\0';
    m_Underwriter_Name[0] = '\0';
    m_Option_type[0] = '\0';
    m_Maturity_Term_News[0] = '\0';
  }
};

class xQBBondTradeTipIssueInfoV5List_c {
 public:
  std::list<xQBBondTradeTipIssueInfoV5_c> m_List;  //
};

//----------------------------------------------
// E_FID_QB_TRADE_TIP_MATURITY_V5				= 50111,
// // 交易提示--付息兑付_V5	tong 请求同50110 应答同50051
//----------------------------------------------
// E_FID_QB_TRADE_TIP_OPTION_EXERCISE_V5			= 50112,
// // 交易提示--行权提示_V5	tong 请求同50110 应答同50052
//----------------------------------------------
// E_FID_QB_TRADE_TIP_RATING_MODIFY_V5			= 50113,
// // 交易提示--评级修正_V5	tong 请求同50110 应答同50053

//----------------------------------------------
// E_FID_QB_BOND_FUNDAMENTAL_REQ				= 50054,
// // 请求计算器需要的基础数据
typedef struct xQBBondFundamentalInfoReq_t {
  std::list<TW_BOND> m_List;
} QBBondFundamentalInfoReq_t, *PQBBondFundamentalInfoReq_t;

class xBondFundamentalInfo_c {
 public:
  char m_Bond_Key[32 + 1];
  char m_ListedMarket[8];
  char m_Bond_ID[12];
  char m_BondSubtype[4];   // 债劵子类别
  char m_ExternalType[4];  // 外部分类
  char m_Interest_Start_Date[12];
  char m_Maturity_Date[12];
  char m_First_Coupon_Date[12];
  char m_Option_Type[SELECTIVE_CODE_LEN];
  char m_Option_Style[SELECTIVE_CODE_LEN];
  int m_Call_No;
  char m_Call_Str[128];
  int m_Put_No;
  char m_Put_Str[128];
  char m_First_Exchg_Bond_Key[32 + 1];
  int m_First_Exchg_No;
  char m_First_Exchg_Str[128];
  int m_Sec_Exchg_No;
  char m_Sec_Exchg_Year[128];
  char m_Assign_Trans_Key[7 + 1];
  int m_Assign_Trans_No;
  char m_Assign_Trans_Str[128];
  char m_Compensate_Rate[10];
  int m_Compensate_From;
  char m_IssuerCode[7 + 1];  // 发行人代码
  char m_Option_Exercise[SELECTIVE_CODE_LEN];
  char m_Option_Exercise_Date[12];
  char m_Coupon_Type[SELECTIVE_CODE_LEN];  // 利率方式
  double m_Coupon_Rate_Spread;
  double m_Coupon_Rate_Current;  // 当前票面利率
  char m_Coupon_Frequency[SELECTIVE_CODE_LEN];
  char m_Compound_Frequency[SELECTIVE_CODE_LEN];
  char m_Interest_Basis[SELECTIVE_CODE_LEN];
  char m_Coupon_Dist[SELECTIVE_CODE_LEN];
  double m_FRN_Multiplier;
  char m_FRN_Index_ID[16];
  double m_First_Index_Rate;
  char m_Fixing_Frequency[SELECTIVE_CODE_LEN];
  int m_Fixing_MA_Days;
  char m_Fixing_Preceds[SELECTIVE_CODE_LEN];
  char m_Fixing_Calendar_Key[SELECTIVE_CODE_LEN];
  char m_Fixing_Tailing[SELECTIVE_CODE_LEN];
  int m_Fixing_Digit;
  char m_Reset_Effective[SELECTIVE_CODE_LEN];
  double m_Cap;
  double m_Flr;
  char m_Simple_Compound[SELECTIVE_CODE_LEN];
  char m_Variable_Schedule[SELECTIVE_CODE_LEN];
  char m_Coupon_Day_Adjust[SELECTIVE_CODE_LEN];
  char m_Coupon_Day_DMC[SELECTIVE_CODE_LEN];
  char m_Coupon_Calendar_Key[SELECTIVE_CODE_LEN];
  char m_Pricing_Conv[SELECTIVE_CODE_LEN];
  double m_Issue_Price;
  int m_Redemption_No;
  char m_Redemption_Str[160];
  char m_Maturity_Adjust[SELECTIVE_CODE_LEN];
  char m_Maturity_DMC[SELECTIVE_CODE_LEN];
  char m_Maturity_Calendar_Key[SELECTIVE_CODE_LEN];
  char m_Listed_Date[12];
  xBondFundamentalInfo_c()
      : m_Call_No(0),
        m_Put_No(0),
        m_First_Exchg_No(0),
        m_Sec_Exchg_No(0),
        m_Assign_Trans_No(0),
        m_Compensate_From(0),
        m_Coupon_Rate_Spread(0),
        m_Coupon_Rate_Current(0),
        m_FRN_Multiplier(0),
        m_First_Index_Rate(0),
        m_Fixing_MA_Days(0),
        m_Fixing_Digit(0),
        m_Cap(0),
        m_Flr(0),
        m_Issue_Price(0),
        m_Redemption_No(0) {
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_Bond_ID, 0, sizeof(m_Bond_ID));
    memset(m_BondSubtype, 0, sizeof(m_BondSubtype));
    memset(m_ExternalType, 0, sizeof(m_ExternalType));
    memset(m_Interest_Start_Date, 0, sizeof(m_Interest_Start_Date));
    memset(m_Maturity_Date, 0, sizeof(m_Maturity_Date));
    memset(m_First_Coupon_Date, 0, sizeof(m_First_Coupon_Date));
    memset(m_Option_Type, 0, sizeof(m_Option_Type));
    memset(m_Option_Style, 0, sizeof(m_Option_Style));
    memset(m_Call_Str, 0, sizeof(m_Call_Str));
    memset(m_Put_Str, 0, sizeof(m_Put_Str));
    memset(m_First_Exchg_Bond_Key, 0, sizeof(m_First_Exchg_Bond_Key));
    memset(m_First_Exchg_Str, 0, sizeof(m_First_Exchg_Str));
    memset(m_Sec_Exchg_Year, 0, sizeof(m_Sec_Exchg_Year));
    memset(m_Assign_Trans_Key, 0, sizeof(m_Assign_Trans_Key));
    memset(m_Assign_Trans_Str, 0, sizeof(m_Assign_Trans_Str));
    memset(m_Compensate_Rate, 0, sizeof(m_Compensate_Rate));
    memset(m_IssuerCode, 0, sizeof(m_IssuerCode));
    memset(m_Option_Exercise, 0, sizeof(m_Option_Exercise));
    memset(m_Option_Exercise_Date, 0, sizeof(m_Option_Exercise_Date));
    memset(m_Coupon_Type, 0, sizeof(m_Coupon_Type));
    memset(m_Coupon_Frequency, 0, sizeof(m_Coupon_Frequency));
    memset(m_Compound_Frequency, 0, sizeof(m_Compound_Frequency));
    memset(m_Interest_Basis, 0, sizeof(m_Interest_Basis));
    memset(m_Coupon_Dist, 0, sizeof(m_Coupon_Dist));
    memset(m_FRN_Index_ID, 0, sizeof(m_FRN_Index_ID));
    memset(m_Fixing_Frequency, 0, sizeof(m_Fixing_Frequency));
    memset(m_Fixing_Preceds, 0, sizeof(m_Fixing_Preceds));
    memset(m_Fixing_Calendar_Key, 0, sizeof(m_Fixing_Calendar_Key));
    memset(m_Fixing_Tailing, 0, sizeof(m_Fixing_Tailing));
    memset(m_Reset_Effective, 0, sizeof(m_Reset_Effective));
    memset(m_Simple_Compound, 0, sizeof(m_Simple_Compound));
    memset(m_Variable_Schedule, 0, sizeof(m_Variable_Schedule));
    memset(m_Coupon_Day_Adjust, 0, sizeof(m_Coupon_Day_Adjust));
    memset(m_Coupon_Day_DMC, 0, sizeof(m_Coupon_Day_DMC));
    memset(m_Coupon_Calendar_Key, 0, sizeof(m_Coupon_Calendar_Key));
    memset(m_Pricing_Conv, 0, sizeof(m_Pricing_Conv));
    memset(m_Redemption_Str, 0, sizeof(m_Redemption_Str));
    memset(m_Maturity_Adjust, 0, sizeof(m_Maturity_Adjust));
    memset(m_Maturity_DMC, 0, sizeof(m_Maturity_DMC));
    memset(m_Maturity_Calendar_Key, 0, sizeof(m_Maturity_Calendar_Key));
    memset(m_Listed_Date, 0, sizeof(m_Listed_Date));
  }
};

class xBondFundamentalInfoList_c {
 public:
  std::list<xBondFundamentalInfo_c> m_List;  // 债券基础信息
};

//----------------------------------------------
// E_FID_QB_HOLIDAY_REQ						= 50059,
// // 获取节假日  ----银行间CIB  tong
typedef struct xQBHolidayReq_t {
  UINT m_BeginDate;  // 查询开始日期
  UINT m_EndDate;    // 查询结束日期
  xQBHolidayReq_t() : m_BeginDate(0), m_EndDate(0) {}
} QBHolidayReq_t, *PQBHolidayReq_t;

class xQBHolidayUnit_c {
 public:
  UINT m_Holiday;               // 节假日
  char m_Country[4];            // 国家
  char m_Market[16];            // 市场
  char m_HolidayReason[32];     // 放假原因
  char m_HolidayReason_En[64];  // 放假原因-英文
  xQBHolidayUnit_c() : m_Holiday(0) {
    memset(m_Country, 0, sizeof(m_Country));
    memset(m_Market, 0, sizeof(m_Market));
    memset(m_HolidayReason, 0, sizeof(m_HolidayReason));
    memset(m_HolidayReason_En, 0, sizeof(m_HolidayReason_En));
  }
};

class xQBHolidayList_c {
 public:
  UINT m_MaxHoliday;                   // 维护的最大节假日
  UINT m_MinHoliday;                   // 维护的最小节假日
  std::list<xQBHolidayUnit_c> m_List;  // 节假日列表
  xQBHolidayList_c() : m_MaxHoliday(0), m_MinHoliday(0) {}
};

//----------------------------------------------
// E_FID_QB_MARKET_STREAM_DEAL_REQ				= 50060,
// // 请求市场动向,成交  anson 请求应答包同E_FID_QB_MARKET_STREAM_REQ

//----------------------------------------------
// E_FID_QB_MARKET_STREAM_DEAL_PUSH				= 50061,
// // 推送市场动向，成交	anson 无请求,应答包同E_FID_QB_MARKET_STREAM_PUSH

//----------------------------------------------
// E_FID_QB_MARKET_STREAM_DEAL_EX_REQ			= 50062,
// // 查询Marketstream 成交 ,高级查询，待筛选条件 anson
// 请求应答包同E_FID_QB_MARKET_STREAM_EX_REQ

// E_FID_QB_TRADE_TIP_SUMMARY2					= 50063,
// // 交易提示--统计tong,返回bondkey列表 请求结构同50050

class xQBBondTradeTipBond_c {
 public:
  char m_Bond_Key[32 + 1];
  char m_Listed_Market[8];
  xQBBondTradeTipBond_c() {
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
  }
};

class xQBBondTradeTipSummary2_c {
 public:
  UINT m_Date;                                         // 日期，20120121
  std::list<xQBBondTradeTipBond_c> m_IssueCntList;     // 发行流通数量
  std::list<xQBBondTradeTipBond_c> m_MaturityCntList;  // 付息兑付数量
  std::list<xQBBondTradeTipBond_c> m_OptionExerciseCntList;  // 行权提示数量
  std::list<xQBBondTradeTipBond_c> m_RatingModifyCntList;  // 评级修正数量
  xQBBondTradeTipSummary2_c() : m_Date(0) {}
};

class xQBBondTradeTipSummaryList2_c {
 public:
  std::list<xQBBondTradeTipSummary2_c> m_List;  // 债券基础信息
};

//----------------------------------------------
// E_FID_QB_TF_TICK_REQ						= 50064,
// // 查询Tick
typedef struct xQBTFTickReq_t {
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  time_t m_beginTime;  // 设置开始时间，如果不设，或者设置0，都代表无穷早
  time_t m_endTime;  // 设置结束时间，如果不设，或者设置0，都代表现在,时间区间的数学表达式(beginTime,
                     // endTime]
  int m_limitCount;  // 记录数量，代表离endTime最近的limit条记录，不设置或者设置-1，表示所有
  xQBTFTickReq_t() : m_beginTime(0), m_endTime(0), m_limitCount(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
} xQBTFTickReq_t, *PQBTFTickReq_t;

class xQBTFTickUnit_c {
 public:
  char m_TradingDay[8 + 1];    //	交易日
  char m_TF_Key[32 + 1];       //  国债期货编码
  char m_InstrumentID[8];      //	合约代码
  float m_LastPrice;           //	最新价
  double m_IncrementInterest;  //	仓差
  int m_LastVolume;            //	最新一笔的数量,--现量
  char m_UpdateTime[24];       //	最后修改时间(HH:MM:SS)
  int m_UpdateMillisec;        //	最后修改毫秒
  float m_BidPrice1;           //	申买价一
  float m_AskPrice1;           //	申卖价一
  float m_AveragePrice;        //	当日均价 add by givins.zhu 2016 11/17
  xQBTFTickUnit_c()
      : m_LastPrice(0),
        m_IncrementInterest(0),
        m_LastVolume(0),
        m_UpdateMillisec(0),
        m_BidPrice1(0),
        m_AskPrice1(0),
        m_AveragePrice(0) {
    memset(m_TradingDay, 0, sizeof(m_TradingDay));
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
    memset(m_UpdateTime, 0, sizeof(m_UpdateTime));
  }
};

class xQBTFTickList_c {
 public:
  std::list<xQBTFTickUnit_c> m_List;  // Tick列表
};

//----------------------------------------------
// E_FID_QB_APPMENU_REQ = 50066,			// 查询QB App目录菜单
// 请求
struct xQBAppMenuReq_c {
  char m_menuVersion[32];  // 目录版本号
  xQBAppMenuReq_c() { memset(this, 0, sizeof(xQBAppMenuReq_c)); }
};
// 应答
struct xQBAppMenuAck_c {
  char m_menuVersion[32];  // 目录版本号
  char m_jsonMenu[40000];  // Json格式文本
  xQBAppMenuAck_c() { memset(this, 0, sizeof(xQBAppMenuAck_c)); }
};

//----------------------------------------------
// E_FID_QB_TF_MARKET_STREAM_REQ				= 50125,
// // 查询国债期货相关现券报价
typedef struct xQBTFMarketStreamReq_t {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
  char m_TF_Key[32 + 1];                 // 国债期货编码
  std::list<TW_BOND> m_Bond;             // 债券列表
  int m_ReplyNum;  // 请求返回的记录数，目前默认100
  xQBTFMarketStreamReq_t() : m_ReplyNum(0) {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
  }
} QBTFMarketStreamReq_t, *PQBTFMarketStreamReq_t;
// 应答同E_FID_QB_MARKET_STREAM_REQ				= 50008,

//----------------------------------------------
// E_FID_QB_TF_MARKET_STREAM_DEAL_REQ			= 50095,
// // 查询国债期货相关现券成交 请求应答同50125

//-----------------------------------------------------------------------------------
// E_FID_QB_CDC_PRICE_DETAIL_REQ				= 50039,
// //个券详情 估值信息 铨 20131221 E_FID_QB_CDC_PRICE_DETAIL_REQ_V2
// = 50344,			//个券详情 估值信息，V3.6后替换原50039消息
typedef struct xQBCDCPriceDetailReq_t {
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_Listed_Market[8];  //
  char m_bond_id[12 + 1];
  char m_Credibility[24];  // 可信度，空为推荐，”推荐“、“非推荐”
  xQBCDCPriceDetailReq_t() { memset(this, 0, sizeof(xQBCDCPriceDetailReq_t)); }
} QBCDCPriceDetailReq_t, *PQBCDCPriceDetailReq_t;

class xQBCDCPriceDetail_c {
 public:
  char m_bond_key[32 + 1];    // Sumscope的BondKey	String
  char m_Listed_Market[8];    //
  float m_CleanPrice;         // 净价
  float m_Yield;              // 收益率
  float m_Modified_Duration;  // 修正久期
  float m_Convexity;          // 估价凸性
  float m_Basis_Point_Value;  // 基点价值
  float m_Spread_Duration;    // 估价利差久期
  float m_Spread_Convexity;   // 估价利差凸性
  char m_Credibility[24];     // 可信度

  float m_Market_Dirty_Price;        // 加权平均结算全价
  float m_Market_Clean_Price;        // 加权平均结算净价
  float m_Market_Yield;              // 加权平均结算价收益率
  float m_Market_Modified_Duration;  // 加权平均结算价修正久期
  float m_Market_Convexity;          // 加权平均结算价凸性
  float m_Market_Basis_Point_Value;  // 加权平均结算价基点价值
  float m_Market_Spread_Duration;    // 加权平均结算价利差久期
  float m_Market_Spread_Convexity;   // 加权平均结算价利差凸性

  UINT m_Date;  // 日期
  xQBCDCPriceDetail_c()
      : m_CleanPrice(0),
        m_Yield(0),
        m_Modified_Duration(0),
        m_Convexity(0),
        m_Basis_Point_Value(0),
        m_Spread_Convexity(0),
        m_Spread_Duration(0),

        m_Market_Dirty_Price(0),
        m_Market_Clean_Price(0),
        m_Market_Yield(0),
        m_Market_Modified_Duration(0),
        m_Market_Convexity(0),
        m_Market_Basis_Point_Value(0),
        m_Market_Spread_Duration(0),
        m_Market_Spread_Convexity(0),
        m_Date(0) {
    m_bond_key[0] = '\0';

    __FIELDCOPY__(m_Listed_Market, "CIB");
    m_Credibility[0] = '\0';
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_ACCOUNT_MANAGER_REQ				= 50077,
// // 查询客户经纪信息 tong
typedef struct xQBAccountManagerReq_t {
  char m_UserId[32 + 1];       // 用户id
  char m_UserAccount[32 + 1];  // 用户登录名
  xQBAccountManagerReq_t() { memset(this, 0, sizeof(xQBAccountManagerReq_t)); }
} QBAccountManagerReq_t, *PQBAccountManagerReq_t;

struct xQBAccountManagerData {
  char m_CSQBAccount[32 + 1];    // 客户经理QBAccount
  char m_CSChineseName[32 + 1];  // 客户经理名
  char m_CSEnglishName[32 + 1];  // 客户经理英文名
  char m_CSTelephone[32 + 1];    // 固定电话
  char m_CSMobile[32 + 1];       // 手机号码
  char m_CSEmail[128 + 1];       // 电子邮箱
  bool m_CSAgent;                // 是否代理
  xQBAccountManagerData() { memset(this, 0, sizeof(xQBAccountManagerData)); };
};

class xQBAccountManagerAck_c {
 public:
  std::list<xQBAccountManagerData> m_data;
  xQBAccountManagerAck_c(){};
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_DAILY_COMMENT_TYPE_REQ		= 50092,
// // 经纪公司日评，品种类型查询 tong
class xQBGoodsType_c {
 public:
  char m_GoodType[8];  // 产品类型
  /*
  SUM 总评
  RTB 利率债总结
  GOV 国债
  CBB 央票
  FIN 金融债
  CDB 国开金融债
  NDB 非国开金融债
  FRN 浮息债
  CDT 信用债总结
  CPB 短融
  MTN 中票
  EPB 企业债
  PPN 私募债
  CIB 城投债
  NCD 同业存单
  OTR 其他
  */
  xQBGoodsType_c() { memset(m_GoodType, 0, sizeof(m_GoodType)); }
};

typedef struct xQBBrokerDailyCommentTypeReq_t {
  char m_UserId[32 + 1];  // 用户id
  int m_CompanyId;        // 公司id
  xQBBrokerDailyCommentTypeReq_t() : m_CompanyId(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBBrokerDailyCommentTypeReq_t, *PQBBrokerDailyCommentTypeReq_t;

class xQBBrokerDailyCommentTypeAck_c {
 public:
  int m_CompanyId;                   // 公司id
  std::list<xQBGoodsType_c> m_List;  // 产品类型列表
  UINT m_Date;                       // 日期
  xQBBrokerDailyCommentTypeAck_c() : m_CompanyId(0), m_Date(0) {}
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_DAILY_COMMENT_REQ			= 50078,
// //经纪公司日评，tong
typedef struct xQBBrokerDailyCommentReq_t {
  int m_CompanyId;  // 公司id
  std::list<xQBGoodsType_c> m_List;
  xQBBrokerDailyCommentReq_t() : m_CompanyId(0) {}
} QBBrokerDailyCommentReq_t, *PQBBrokerDailyCommentReq_t;

class xQBBrokerDailyCommentUnit_c {
 public:
  int m_CompanyId;      // 公司id
  char m_GoodType[8];   //
  char m_GoodLevel[6];  // 评级
  char m_Term[10];      // 期限
  char m_ItemType[4];   // TRT	今日收益率;		YRT	昨日收益率;
                       // SPD	今日与昨日变动
  char m_Rate[10];  // 收益率
  UINT m_Date;      // 日期
  xQBBrokerDailyCommentUnit_c() : m_CompanyId(0), m_Date(0) {
    memset(m_GoodType, 0, sizeof(m_GoodType));
    memset(m_GoodLevel, 0, sizeof(m_GoodLevel));
    memset(m_Term, 0, sizeof(m_Term));
    memset(m_ItemType, 0, sizeof(m_ItemType));
    memset(m_Rate, 0, sizeof(m_Rate));
  }
};

class xQBBrokerDailyCommentList_c {
 public:
  char m_Comments[1024 * 3];                      // 评论
  std::list<xQBBrokerDailyCommentUnit_c> m_List;  //
  xQBBrokerDailyCommentList_c() { memset(m_Comments, 0, sizeof(m_Comments)); }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_DAILY_DEAL_REQ				= 50079,
// // 经纪公司日评，成交 tong 请求同50078
class xQBBrokerDailyDealUnit_c {
 public:
  int m_CompanyId;            // 公司id
  char m_GoodType[8];         // 类型
  char m_Term[10];            // 期限
  char m_Bond_id[12];         // 债券代码
  char m_Short_Name[32 + 1];  // 简称
  char m_Goods_level[6];      // 评级
  char m_Price[12];           // 价
  UINT m_Date;                // 日期
  xQBBrokerDailyDealUnit_c() : m_CompanyId(0), m_Date(0) {
    memset(m_GoodType, 0, sizeof(m_GoodType));
    memset(m_Term, 0, sizeof(m_Term));
    memset(m_Bond_id, 0, sizeof(m_Bond_id));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_Goods_level, 0, sizeof(m_Goods_level));
    memset(m_Price, 0, sizeof(m_Price));
  }
};

class xQBBrokerDailyDealList_c {
 public:
  std::list<xQBBrokerDailyDealUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_DAILY_SPREAD_REQ			= 50080,
// // 经纪公司日评，基准价差 tong
class xQBGoodsLevel_c {
 public:
  char m_GoodLevel[16];  // AAA+；AAA；AA+；AA
  xQBGoodsLevel_c() { memset(m_GoodLevel, 0, sizeof(m_GoodLevel)); }
};
typedef struct xQBBrokerDailySpreadReq_t {
  int m_CompanyId;  // 公司id
  char m_ItemType[4];  // 与国债利差 SGV;与金融债利差 SFN;国债收益率
                       // GOV;金融债收益率 FIN
  char m_GoodType[8];  // 产品类型，
  std::list<xQBGoodsLevel_c>
      m_List;  // 如果itemType 是SGV、SFN
               // 则根据此list的值筛选，其余类型不用看这个参数
  xQBBrokerDailySpreadReq_t() : m_CompanyId(0) {
    memset(m_ItemType, 0, sizeof(m_ItemType));
    memset(m_GoodType, 0, sizeof(m_GoodType));
  }
} QBBrokerDailySpreadReq_t, *PQBBrokerDailySpreadReq_t;

class xQBBrokerDailySpreadUnit_c {
 public:
  int m_CompanyId;  // 公司id
  char m_GoodType[8];
  char m_GoodLevel[6];  // 评级
  char m_Term[8];       // 期限
  char m_ItemType[4];  // 与国债利差 SGV;与金融债利差 SFN;国债收益率
                       // GOV;金融债收益率 FIN
  char m_Rate[10];  // 收益率
  UINT m_Date;      // 日期
  xQBBrokerDailySpreadUnit_c() : m_CompanyId(0), m_Date(0) {
    memset(m_GoodType, 0, sizeof(m_GoodType));
    memset(m_GoodLevel, 0, sizeof(m_GoodLevel));
    memset(m_Term, 0, sizeof(m_Term));
    memset(m_ItemType, 0, sizeof(m_ItemType));
    memset(m_Rate, 0, sizeof(m_Rate));
  }
};

class xQBBrokerDailySpreadList_c {
 public:
  std::list<xQBBrokerDailySpreadUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_ADD_REQ						= 50081,
// // 提醒，增加 tong
struct xPriceCondition_c {
 public:
  bool m_PriceAppear;      // 价格出现 true 表示有设置，反之没设
  bool m_DealDone;         // 成交 true 表示有设置，反之没设
  bool m_PriceArea;        // 价格区间 true 表示有设置，反之没设
  float m_BidPrice;        //
  char m_BidCondition[8];  //">","<",">=","<=","=="，""表示没设
  float m_OfrPrice;        //
  char m_OfrCondition[8];  //">","<",">=","<=","=="，""表示没设
  float m_Spread;          //
  char m_SpreadCondition[8];  //">","<",">=","<=","=="，""表示没设

  float m_DealPrice;             // 成交价格
  char m_DealPriceContidion[8];  // 成交价格条件
                                 // ">","<",">=","<=","=="，""表示没设
  float m_CdcBidSpread;          // bid-估值
  char m_CdcBidCondition[8];  // bid-估值条件 ">","<",">=","<=","=="，""表示没设
  float m_CdcOfrSpread;  // 估值-ofr
  char m_CdcOfrCondition[8];  // 估值-ofr条件 ">","<",">=","<=","=="，""表示没设
  float m_CdcDealSpread;  // |估值-成交|
  char m_CdcDealCondition[8];  // |估值-成交| ">","<",">=","<=","=="，""表示没设
  xPriceCondition_c() { memset(this, 0, sizeof(xPriceCondition_c)); }
};

class xCalendarCondition_c {
 public:
  int m_BeforeDays;  // 提前天数
  bool m_BeOnce;     // true,仅提醒一次；false,循环提醒
  bool m_Pay;        // 付息 true 表示有设置，反之没设
  bool m_Option;     // 行权 true 表示有设置，反之没设
  bool m_Maturity;   // 到期 true 表示有设置，反之没设
  xCalendarCondition_c()
      : m_BeforeDays(0),
        m_BeOnce(false),
        m_Pay(false),
        m_Option(false),
        m_Maturity(false) {}
};

class xRatingCondition_c {
 public:
  bool m_RatingUpdate;     // 评级更新 true 表示有设置，反之没设
  bool m_RatingChange;     // 评级变动 true 表示有设置，反之没设
  bool m_ProspectsChange;  // 展望变动 true 表示有设置，反之没设
  xRatingCondition_c()
      : m_RatingUpdate(false),
        m_RatingChange(false),
        m_ProspectsChange(false) {}
};
class xBondKey_c {
 public:
  char m_Bond_Key[32 + 1];  // 债券Key
  char m_Listed_Market[8];  // 市场代码
  xBondKey_c() {
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
  }
};
typedef struct xQBReminderAddReq_t {
  char m_Bond_Key[32 + 1];  // 债券Key
  char m_ListedMarket[8];   // 市场代码
  char m_BondID[12];        // bond ID、bond code;	唯一,除非为空
                            // //债券
  char m_Short_Name[32];    // 债券简称
  char m_GroupID[32 + 1];  // 关注组ID，有key则此为空，有此值则key为空
  char m_InstitutionID[32 + 1];  // 机构ID，m_ReminderIssuerNews = true时有效
  char m_UserId[32 + 1];         // 用户id

  char m_UserAccount[64];  // 用户名

  xPriceCondition_c m_PriceCondition;        // 价格提醒
  xCalendarCondition_c m_CalendarCondition;  // 日历事件
  xRatingCondition_c m_RatingCondition;      // 评级事件
  int m_ReminderStatus;  // 提醒状态，1--打开，2--关闭，3--作废
  bool m_ReminderIssuerNews;  // 债券事件
  bool m_PopWindow;           // 提醒方式,悬浮窗
  bool m_MessageCenter;       // 提醒方式,消息中心
  bool m_QM;                  // 提醒方式,QM
  bool m_Email;               // 提醒方式,email
  bool m_Sound;               // 提醒方式,声音
  xQBReminderAddReq_t()
      : m_ReminderStatus(0),
        m_ReminderIssuerNews(false),
        m_PopWindow(false),
        m_MessageCenter(false),
        m_QM(false),
        m_Email(false),
        m_Sound(false) {
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_GroupID, 0, sizeof(m_GroupID));
    memset(m_InstitutionID, 0, sizeof(m_InstitutionID));
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderAddReq_t, *PQBReminderAddReq_t;

class xQBReminderAddAck_c {
 public:
  char m_ReminderId[32 + 1];  // 提醒ID
  time_t m_Time;              // 关注时间

  xQBReminderAddAck_c() : m_Time(0) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_DEL_REQ						= 50082,
// // 提醒，删除 tong
typedef struct xQBReminderDelReq_t {
  char m_ReminderId[32 + 1];  // 提醒ID
  char m_UserId[33];          // 用户Id add by lizhiqin 20151224
  xQBReminderDelReq_t() {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBReminderDelReq_t, *PQBReminderDelReq_t;

class xQBReminderDelAck_c {
 public:
  char m_ReminderId[32 + 1];  // 提醒ID
  char m_UserId[33];          // 用户Id add by lizhiqin 20151224
  xQBReminderDelAck_c() {
    m_ReminderId[0] = '\0';
    memset(m_UserId, 0, sizeof(m_UserId));
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MODIFY_REQ					= 50083,
// // 提醒，修改 tong
typedef struct xQBReminderModifyReq_t {
  char m_ReminderId[32 + 1];  // 提醒ID
  char m_Bond_Key[32 + 1];    // 债券Key
  char m_ListedMarket[8];     // CIB/SSE/SZE 代表不同的市场
  char m_BondID[12];          // bond ID、bond code;	唯一,除非为空
                              // //债券
  char m_Short_Name[32];      // 债券简称
  char m_GroupID[32 + 1];  // 关注组ID，有key则此为空，有此值则key为空
  char m_InstitutionID[32 + 1];  // 机构ID，m_ReminderIssuerNews = true时有效

  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名

  xPriceCondition_c m_PriceCondition;        // 价格提醒
  xCalendarCondition_c m_CalendarCondition;  // 日历事件
  xRatingCondition_c m_RatingCondition;      // 评级事件
  int m_ReminderStatus;  // 提醒状态，1--打开，2--关闭，3--作废
  bool m_ReminderIssuerNews;  // 债券事件
  bool m_PopWindow;           // 提醒方式,悬浮窗
  bool m_MessageCenter;       // 提醒方式,消息中心
  bool m_QM;                  // 提醒方式,QM
  bool m_Email;               // 提醒方式,email
  bool m_Sound;               // 提醒方式,声音
  xQBReminderModifyReq_t()
      : m_ReminderStatus(0),
        m_ReminderIssuerNews(false),
        m_PopWindow(false),
        m_MessageCenter(false),
        m_QM(false),
        m_Email(false),
        m_Sound(false) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_GroupID, 0, sizeof(m_GroupID));
    memset(m_InstitutionID, 0, sizeof(m_InstitutionID));
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderModifyReq_t, *PQBReminderModifyReq_t;

class xQBReminderModifyAck_c {
 public:
  char m_ReminderId[32 + 1];  // 提醒ID
  time_t m_Time;              // 关注时间
  xQBReminderModifyAck_c() {
    m_ReminderId[0] = '\0';
    m_Time = 0;
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_QUERY_REQ						= 50084,
// // 提醒，查询 tong
typedef struct xQBReminderQueryReq_t {
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  time_t m_BeginTime;      // 开始时间	-1，从最早开始
  time_t m_EndTime;        // 结束时间	-1，到最新
  int m_Version;           // 版本
  xQBReminderQueryReq_t() : m_BeginTime(0), m_EndTime(0), m_Version(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderQueryReq_t, *PQBReminderQueryReq_t;

class xQBReminderUnit_c {
 public:
  char m_ReminderId[32 + 1];  // 提醒ID
  char m_Bond_Key[32 + 1];    // 债券Key
  char m_ListedMarket[8];     // CIB/SSE/SZE 代表不同的市场
  char m_BondID[12];          // bond ID、bond code;	唯一,除非为空
                              // //债券
  char m_Short_Name[32];      // 债券简称

  char m_GroupID[32 + 1];  // 关注组ID，有key则此为空，有此值则key为空
  char m_InstitutionID[32 + 1];  // 机构ID，m_ReminderIssuerNews = true时有效

  xPriceCondition_c m_PriceCondition;        // 价格提醒
  xCalendarCondition_c m_CalendarCondition;  // 日历事件
  xRatingCondition_c m_RatingCondition;      // 评级事件
  int m_ReminderStatus;  // 提醒状态，1--打开，2--关闭，3--作废
  bool m_ReminderIssuerNews;  // 债券事件
  bool m_PopWindow;           // 提醒方式,悬浮窗
  bool m_MessageCenter;       // 提醒方式,消息中心
  bool m_QM;                  // 提醒方式,QM
  bool m_Email;               // 提醒方式,email
  bool m_Sound;               // 提醒方式,声音
  time_t m_Time;              // 关注时间
  xQBReminderUnit_c()
      : m_ReminderStatus(0),
        m_ReminderIssuerNews(false),
        m_PopWindow(false),
        m_MessageCenter(false),
        m_QM(false),
        m_Email(false),
        m_Sound(false),
        m_Time(0) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_BondID, 0, sizeof(m_BondID));
    memset(m_Short_Name, 0, sizeof(m_Short_Name));
    memset(m_GroupID, 0, sizeof(m_GroupID));
    memset(m_InstitutionID, 0, sizeof(m_InstitutionID));
  }
};

class xQBReminderList_c {
 public:
  std::list<xQBReminderUnit_c> m_List;
};

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MESSAGE_QUERY_REQ			= 50085,
// // 提醒，消息查询 tong
typedef struct xQBReminderMessageQueryReq_t {
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  time_t m_BeginTime;      // 开始时间	-1，从最早开始
  time_t m_EndTime;        // 结束时间	-1，到最新
  xQBReminderMessageQueryReq_t() : m_BeginTime(0), m_EndTime(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderMessageQueryReq_t, *PQBReminderMessageQueryReq_t;

class xQBReminderMessageUnit_c {
 public:
  char m_UserId[32 + 1];      // 用户id
  char m_UserAccount[64];     // 用户名
  char m_MessageId[32 + 1];   // 提醒的消息ID
  char m_ReminderId[32 + 1];  // 提醒ID
  char m_Bond_Key[32 + 1];    // 债券Key
  char m_ListedMarket[8];     // CIB/SSE/SZE 代表不同的市场
  char m_InstitutionID[32 + 1];  // 机构ID，当m_ReminderType = IssuerNews时有效
  char m_ReminderType[32];  // "Price","Calendar","Rating","IssuerNews"

  char m_Type[33];     // 分类：债券、国债期货
  char m_SubType[33];  // 子分类

  char m_MessageTitle[96];      // 消息标题
  char m_MessageInfo[512];      // 消息内容
  char m_MessageTitle_En[128];  // 消息标题-英文
  char m_MessageInfo_En[512];   // 消息内容-英文
  char m_NewsID[32];            // 债市情报新闻ID
  int m_ReadFlag;               // 0 未读 1 已读
  int m_CollFlag;               // 0 未收藏 1 已收藏
  int m_DelFlag;                // 0 未删除 1 已删除
  int m_Importance;             // 0  普通  1 重要

  time_t m_Time;  // 消息时间
  xQBReminderMessageUnit_c()
      : m_ReadFlag(0), m_CollFlag(0), m_DelFlag(0), m_Importance(0), m_Time(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_MessageId, 0, sizeof(m_MessageId));
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_Bond_Key, 0, sizeof(m_Bond_Key));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_InstitutionID, 0, sizeof(m_InstitutionID));
    memset(m_ReminderType, 0, sizeof(m_ReminderType));
    memset(m_Type, 0, sizeof(m_Type));
    memset(m_SubType, 0, sizeof(m_SubType));

    memset(m_MessageTitle, 0, sizeof(m_MessageTitle));
    memset(m_MessageInfo, 0, sizeof(m_MessageInfo));
    memset(m_MessageTitle_En, 0, sizeof(m_MessageTitle_En));
    memset(m_MessageInfo_En, 0, sizeof(m_MessageInfo_En));
    memset(m_NewsID, 0, sizeof(m_NewsID));
  }
};

class xQBReminderMessageList_c {
 public:
  std::list<xQBReminderMessageUnit_c> m_List;
};

// E_FID_QB_REMINDER_BOND_MESSAGE_PUSH = 50655,			//
// 债券弹窗提醒，消息推送 new 无请求，注册到QB本地， 应答同50085

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MESSAGE_PUSH				= 50086,
// // 提醒，消息推送 anson 无请求，应答同50085
//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MESSAGE_PUSH				= 50086,
// // 提醒，消息推送 anson 无请求，应答同50085

//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MESSAGE_BASE_QUERY				= 50239,
// // 提醒，消息条数查询 查询未读条数
typedef struct xQBReminderMessageBaseQuery_t {
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  time_t m_tBeginTime;     //
  time_t m_tEndTime;
  xQBReminderMessageBaseQuery_t() : m_tBeginTime(0), m_tEndTime(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderMessageBaseQuery_t, *PQBReminderMessageBaseQuery_t;

class xQBReminderMessageBaseInfo {
 public:
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  int m_UnReadMsg;         // 未读信息
  xQBReminderMessageBaseInfo() : m_UnReadMsg(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
};
//-----------------------------------------------------------------------------------
// E_FID_QB_REMINDER_MESSAGE_MODIFY				= 50238,
// // 提醒，消息修改 修改消息状态

typedef struct xQBRemindModifyUnit {
  char m_MessageId[32 + 1];
  xQBRemindModifyUnit() { memset(m_MessageId, 0, sizeof(m_MessageId)); }
} QBRemindModifyUnit;
// 请求
typedef struct xQBReminderModifyMessageReq_t {
  char m_UserId[32 + 1];
  char m_UserAccount[64];  // 用户名
  std::list<QBRemindModifyUnit> m_List;
  int m_OperateType;  // 0 是否已读 1 是否收藏 2 是否删除 3是否重要
  int m_OperateValue;  // 1 是 ,0 否
  xQBReminderModifyMessageReq_t() : m_OperateType(0), m_OperateValue(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
} QBReminderModifyMessageReq;

// 应答
typedef struct xQBRedminderModifyMessageAck_t {
  std::list<QBRemindModifyUnit> m_List;
  int m_OperateType;  // 0 是否已读 1 是否收藏 2 是否删除  3是否重要
  int m_OperateValue;  // 0 是 1 否
  xQBRedminderModifyMessageAck_t() : m_OperateType(0), m_OperateValue(0) {}
} QBRedminderModifyMessageAck;
//-----------------------------------------------------------------------------------
class xConditionGroupId_c {
 public:
  char m_ConditionGroupId[32 + 1];  // 方案ID
  xConditionGroupId_c() {
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
  }
};

// E_FID_QB_CONDITION_GRUOP_REQ_NEW = 50099,			//
// 筛选方案，合并原先 50091 + 50087 请求
typedef xQBBasicRequestWithUser xQBConditionGroupReqNew;
// 应答
class xQBConditionGroupUnit_c {
 public:
  char m_ConditionGroupId[32 + 1];    // 方案ID
  char m_ConditionGroupName[32 + 1];  // 方案名称
  char m_ConditionBuf[40960];         // 方案buf,字符串
  BondsFilter m_BondFilter;           // 方案内容
  int m_SortID;                       // 方案排序字段
  time_t m_Time;                      // 修改时间
  xQBConditionGroupUnit_c() : m_SortID(0), m_Time(0) {
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
    memset(m_ConditionGroupName, 0, sizeof(m_ConditionGroupName));
    memset(m_ConditionBuf, 0, sizeof(m_ConditionBuf));
  }
};

class xQBConditionGroupList_c {
 public:
  std::list<xQBConditionGroupUnit_c> m_List;
};

////E_FID_QB_BOND_SS_RATING_HIS                 = 50240,
/////查询债券评级机构
// typedef struct xQBBondRatingReq_t {
//	//TW_BOND m_Bond;//债券信息
// }QBBondRatingReq_t, *PQBBondRatingReq_t;
//
// class xQBBondRatingAck_c {
// public:
//	char					m_CompanyId[128];
//// 多个评级机构ID用 '|' 隔开 	xQBBondRatingAck_c(){ 		memset(m_CompanyId, 0,
//sizeof(m_CompanyId));
//	}
// };

//	E_FID_QB_BOND_SS_CREDIT_TYPE                = 50241,
////查询债券增信方式       //童兴国
typedef struct xQBBondCreditTypeReq_t {
  TW_BOND m_Bond;  // 债券信息
} QBBondCreditTypeReq_t, *PQBBondCreditTypeReq_t;

class xQBBondCreditTypeUnit_c {
 public:
  char m_CreditType[64];      // 增信类别
  char m_CreditType_EN[128];  // 增信类别
  char m_SubType[64];         // 子类别
  char m_SubType_EN[128];     // 子类别
  char m_Summary[256];        // 摘要
  char m_Detail[1024];        // 详细

  xQBBondCreditTypeUnit_c() {
    memset(m_CreditType, 0, sizeof(m_CreditType));
    memset(m_CreditType_EN, 0, sizeof(m_CreditType_EN));
    memset(m_SubType, 0, sizeof(m_SubType));
    memset(m_SubType_EN, 0, sizeof(m_SubType_EN));
    memset(m_Summary, 0, sizeof(m_Summary));
    memset(m_Detail, 0, sizeof(m_Detail));
  }
};

class xQBBondCreditTypeAck_c {
 public:
  char m_BondKey[32 + 1];                    // bondKey;				唯一
  char m_Listed_Market[SELECTIVE_CODE_LEN];  // 发行市场
  std::list<xQBBondCreditTypeUnit_c> m_List;

  xQBBondCreditTypeAck_c() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
  }
};

// E_FID_QB_BOND_SS_BUSINESS_DATE              = 50242,
// //查询债券发行人营业分布时间//童兴国
typedef struct xQBBondBusinessDateReq_t {
  char m_IssuerCode[16];  // 发行人代码
  xQBBondBusinessDateReq_t() { memset(m_IssuerCode, 0, sizeof(m_IssuerCode)); }
} QBBondBusinessDateReq_t, *PQBBondBusinessDateReq_t;

class xQBBondBusinessDateUnit_c {
 public:
  char m_Date[12];  // 营业时间
  xQBBondBusinessDateUnit_c() { memset(m_Date, 0, sizeof(m_Date)); }
};

class xQBBondBusinessDateAck_c {
 public:
  char m_IssuerCode[16];  // 发行人代码
  std::list<xQBBondBusinessDateUnit_c> m_List;
  xQBBondBusinessDateAck_c() { memset(m_IssuerCode, 0, sizeof(m_IssuerCode)); }
};

// E_FID_QB_BOND_SS_BUSINESS_DISTRIBUTE        = 50243,
// //查询债券发行人营业分布//童兴国
typedef struct xQBBondBusinessDistributeReq_t {
 public:
  char m_Date[12];        // 营业时间
  char m_IssuerCode[16];  // 发行人代码
  xQBBondBusinessDistributeReq_t() {
    memset(m_Date, 0, sizeof(m_Date));
    memset(m_IssuerCode, 0, sizeof(m_IssuerCode));
  }
} QBBondBusinessDistributeReq_t, *PQBBondBusinessDistributeReq_t;

class xQBBondBusinessDistributeUnit_c {
 public:
  double m_Index_value;         // 主营收入
  char m_Item_content[64];      // 类型
  char m_Item_content_EN[128];  // 类型英文
  char m_unit_type[12];         // 单位
  char m_unit_type_EN[32];      // 单位英文
  char m_Percent[8];            // 百分比
  xQBBondBusinessDistributeUnit_c() : m_Index_value(0.0f) {
    memset(m_Item_content, 0, sizeof(m_Item_content));
    memset(m_Item_content_EN, 0, sizeof(m_Item_content_EN));
    memset(m_unit_type, 0, sizeof(m_unit_type));
    memset(m_unit_type_EN, 0, sizeof(m_unit_type_EN));
    memset(m_Percent, 0, sizeof(m_Percent));
  }
};

class xQBBondBusinessDistributeAck_c {
 public:
  char m_IssuerCode[16];    // 发行人代码
  char m_Date[12];          // 营业时间
  char m_IndexName[32];     // 主营收入名称
  char m_IndexName_EN[32];  // 主营收入名称
  std::list<xQBBondBusinessDistributeUnit_c> m_List;
  xQBBondBusinessDistributeAck_c() {
    memset(m_IssuerCode, 0, sizeof(m_IssuerCode));
    memset(m_Date, 0, sizeof(m_Date));
    memset(m_IndexName, 0, sizeof(m_IndexName));
    memset(m_IndexName_EN, 0, sizeof(m_IndexName_EN));
  }
};

// E_FID_QB_SQS_PRICE_SINGLE_HIS_REQ			= 50245,
// //个券详情 单券历史 上清所估值信息 anson&童兴国 请求应答同50098

//-----------------------------------------------------------------------------------
// E_FID_QB_CONDITION_GRUOP_ADD				= 50088,
// // 筛选方案，增加 tong
typedef struct xQBConditionGroupAddReq_t {
  char m_UserId[32 + 1];              // 用户id
  char m_ConditionGroupName[32 + 1];  // 方案名称
  BondsFilter m_BondFilter;           // 方案内容
  char m_ConditionBuf[40960];         // 方案buf
  UINT m_Version;  // 1.9之前版本为0 ；1.9为 1.9 以后累加
  xQBConditionGroupAddReq_t() : m_Version(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_ConditionGroupName, 0, sizeof(m_ConditionGroupName));
    memset(m_ConditionBuf, 0, sizeof(m_ConditionBuf));
  }
} QBConditionGroupAddReq_t, *PQBConditionGroupAddReq_t;

class xQBConditionGroupAddAck_c {
 public:
  char m_ConditionGroupId[32 + 1];  // 方案ID
  int m_SortID;                     // 方案排序字段
  time_t m_Time;                    // 修改时间
  xQBConditionGroupAddAck_c() : m_Time(0), m_SortID(0) {
    m_ConditionGroupId[0] = '\0';
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_CONDITION_GRUOP_DEL				= 50089,
// // 筛选方案，删除 tong
typedef struct xQBConditionGroupDelReq_t {
  char m_UserId[32 + 1];            // 用户id
  char m_ConditionGroupId[32 + 1];  // 方案ID
  xQBConditionGroupDelReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
  }
} QBConditionGroupDelReq_t, *PQBConditionGroupDelReq_t;

class xQBConditionGroupDelAck_c {
 public:
  char m_ConditionGroupId[32 + 1];  // 方案ID
  xQBConditionGroupDelAck_c() {
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_CONDITION_GRUOP_MODIFY				= 50090,
// // 筛选方案，修改 tong
typedef struct xQBConditionGroupModifyReq_t {
  char m_UserId[32 + 1];              // 用户id
  char m_ConditionGroupId[32 + 1];    // 方案ID
  char m_ConditionGroupName[32 + 1];  // 方案名称
  BondsFilter m_BondFilter;           // 方案内容
  char m_ConditionBuf[40960];         // 方案buf
  UINT m_Version;  // 1.9之前版本为0 ；1.9为 1.9 以后累加
  xQBConditionGroupModifyReq_t() : m_Version(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
    memset(m_ConditionGroupName, 0, sizeof(m_ConditionGroupName));
    memset(m_ConditionBuf, 0, sizeof(m_ConditionBuf));
  }
} QBConditionGroupModifyReq_t, *PQBConditionGroupModifyReq_t;

class xQBConditionGroupModifyAck_c {
 public:
  char m_ConditionGroupId[32 + 1];  // 方案ID
  time_t m_Time;                    // 修改时间
  xQBConditionGroupModifyAck_c() : m_Time(0) { m_ConditionGroupId[0] = '\0'; }
};

//--------------------------------------------------------------------------
// E_FID_QB_CONDITION_SORT						= 50180,
// //筛选方案排序
typedef struct xQBConditionSortReq_t {
  char m_UserId[32 + 1];            // 用户id
  char m_ConditionGroupId[32 + 1];  // 方案ID
  // From 移到End，结果： {FromSortID = EndSortID，(FromSortID， EndSortID]--;
  // FromSortID< EndSortID} 或者 {FromSortID =
  // EndSortID，[EndSortID,FromSortID)++; FromSortID>=EndSortID};
  char m_FromConditionGroupId[32 + 1];  // 方案ID
  int m_FromSortId;                     // 排序ID

  char m_EndConditionGroupId[32 + 1];  // 方案ID，空则为移到最后
  int m_EndSortId;                     // 排序ID
  xQBConditionSortReq_t() : m_FromSortId(0), m_EndSortId(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_ConditionGroupId, 0, sizeof(m_ConditionGroupId));
    memset(m_FromConditionGroupId, 0, sizeof(m_FromConditionGroupId));
    memset(m_EndConditionGroupId, 0, sizeof(m_EndConditionGroupId));
  }
} QBConditionSortReq_t, *PQBConditionSortReq_t;

// 无应答包体

//-----------------------------------------------------------------------------------
// E_FID_QB_MARKET_STREAM_BY_GROUP_QRY			= 50093,
// // 请求市场动向(按"关注组"查询)
typedef struct xQBMarketStreamByGroupIDReq_t {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
  int m_ReplyNum;  // 请求返回的记录数，目前默认100,成交则填-1
  char m_GroupId[32 + 1];  // 分类id
  xQBMarketStreamByGroupIDReq_t() : m_ReplyNum(0) {
    memset(m_GroupId, 0, sizeof(m_GroupId));
  }
} QBMarketStreamByGroupIDReq_t, *PQBMarketStreamByGroupIDReq_t;
// 应答同50008

//-----------------------------------------------------------------------------------
// E_FID_QB_CDC_PRICE_SINGLE_HIS_REQ			= 50098,
// //个券详情 单券历史 估值信息 铨 20150119 E_FID_QB_CDC_PRICE_SINGLE_HIS_REQ_V2
// = 50346,			//个券详情 单券历史，V3.6后替换原50098消息
typedef struct xQBCDCPriceSingleHisReq_t {
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_Listed_Market[8];  //
  char m_bond_id[12 + 1];
  char m_Credibility[24];  // 可信度，空为推荐，”推荐“、“非推荐”
  time_t m_DateBegin;  // 查询开始时间,-1 表示为当天
  time_t m_DateEnd;    // 查询结束时间,-1 表示当天
  int m_ValueCount;  // 估值数据个数,当大于0时按估值点个数进行请求使用
  xQBCDCPriceSingleHisReq_t() : m_DateBegin(-1), m_DateEnd(-1) {
    memset(m_bond_key, 0, sizeof(m_bond_key));
    memset(m_Listed_Market, 0, sizeof(m_Listed_Market));
    memset(m_bond_id, 0, sizeof(m_bond_id));
    memset(m_Credibility, 0, sizeof(m_Credibility));
    m_ValueCount = 0;
  }
} QBCDCPriceSingleHisReq_t, *PQBCDCPriceSingleHisReq_t;

class xQBCDCPriceSingleHis_c {
 public:
  time_t m_Date;               // 中债估值时间
  float m_CleanPrice;          // 净价
  float m_FullPRice;           // 全价
  float m_Yield;               // 收益率
  float m_Modified_Duration;   // 修正久期
  float m_Convexity;           // 估价凸性
  float m_Basis_Point_Value;   // 基点价值
  float m_Spread_Duration;     // 估价利差久期
  float m_Spread_Convexity;    // 估价利差凸性
  char m_Credibility[24];      // 可信度
  char m_cdcExercise[2];       // 中债估值行权到期  (0-行权 1-到期)
  float m_Market_Dirty_Price;  // 加权平均结算全价
  float m_Market_Clean_Price;  // 加权平均结算净价
  float m_Market_Yield;        // 加权平均结算价收益率
  float m_Market_Modified_Duration;  // 加权平均结算价修正久期
  float m_Market_Convexity;          // 加权平均结算价凸性
  float m_Market_Basis_Point_Value;  // 加权平均结算价基点价值
  float m_Market_Spread_Duration;    // 加权平均结算价利差久期
  float m_Market_Spread_Convexity;   // 加权平均结算价利差凸性
  xQBCDCPriceSingleHis_c()
      : m_CleanPrice(0),
        m_FullPRice(0),
        m_Yield(0),
        m_Modified_Duration(0),
        m_Convexity(0),
        m_Basis_Point_Value(0),
        m_Spread_Convexity(0),
        m_Spread_Duration(0),

        m_Market_Dirty_Price(0),
        m_Market_Clean_Price(0),
        m_Market_Yield(0),
        m_Market_Modified_Duration(0),
        m_Market_Convexity(0),
        m_Market_Basis_Point_Value(0),
        m_Market_Spread_Duration(0),
        m_Market_Spread_Convexity(0),
        m_Date(0) {
    m_Credibility[0] = '\0';
    m_cdcExercise[0] = '\0';
  }
  bool operator<(const xQBCDCPriceSingleHis_c& obj) const {
    return m_Date < obj.m_Date;
  }
};

class xQBCDCPriceSingleHisAck_c {
 public:
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_Listed_Market[8];  //
  std::list<xQBCDCPriceSingleHis_c> m_PriceList;
  xQBCDCPriceSingleHisAck_c() {
    m_bond_key[0] = '\0';
    __FIELDCOPY__(m_Listed_Market, "CIB");
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_DAILY_COMPANY_REQ			= 50115,
// // 经纪商日评，查询可以看的经纪商日评的经纪公司列表	tong
typedef xQBBasicRequestWithUser QBBrokerDailyCompanyReq_t;

class xQBBrokerDailyCompanyAck_c {
 public:
  std::list<xQBTradeCmpyInfo_c> m_List;  // 允许放日评的经纪公司
};

//-----------------------------------------------------------------------------------
// E_FID_QB_AUTHORITY_QUERY_NEW_REQ			= 50155,
// // QB 权限查询 tong,新的权限查询
typedef struct xQBAuthorityQueryReq_t {
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  xQBAuthorityQueryReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_CompanyId, 0, sizeof(m_CompanyId));
  }
} QBAuthorityQueryReq_t, *PQBAuthorityQueryReq_t;

class xLevelItem_c {  // 拉点方案详情
 public:
  char m_BusinessLevel[32 + 1];  // 业务基本
  char m_ItemKey[128];           // key
  char m_Value[64];              // Value
  char m_PriceType
      [32];  // 方案拉点时使用的价格类型.BILATERAL:双边报价,INDICATIVE:参考价
  char m_MemoFlag[8];  // 方案是否有备注.0：无,1:有
  xLevelItem_c() {
    memset(m_BusinessLevel, 0, sizeof(m_BusinessLevel));
    memset(m_ItemKey, 0, sizeof(m_ItemKey));
    memset(m_Value, 0, sizeof(m_Value));
    memset(m_PriceType, 0, sizeof(m_PriceType));
    memset(m_MemoFlag, 0, sizeof(m_MemoFlag));
  }
  bool operator==(const xLevelItem_c& stItem) {
    if (strcmp(stItem.m_ItemKey, m_ItemKey) == 0) return true;
    return false;
  }
};

class xQBAuthorityBroker_c {
 public:
  char m_UserName[64];     // 联系人帐号
  char m_DisplayName[64];  // 联系人显示名字
  char m_Mobile[32];       // 手机
  char m_Department[45];   // 部门，"BNC"--利率，"BCO"--信用
  char m_TEL[32];          // 电话
  char m_Email[64];        // email
  xQBAuthorityBroker_c() {
    memset(m_UserName, 0, sizeof(m_UserName));
    memset(m_DisplayName, 0, sizeof(m_DisplayName));
    memset(m_Mobile, 0, sizeof(m_Mobile));
    memset(m_Department, 0, sizeof(m_Department));
    memset(m_TEL, 0, sizeof(m_TEL));
    memset(m_Email, 0, sizeof(m_Email));
  }
};

class xQBAuthorityBusiness_c {
 public:
  char m_BrokerID[32 + 1];         // 经纪公司ID
  char m_BrokerName[64];           // 经纪公司名字
  char m_CompanyType[4];           // 1--机构报价  Leaf， 0--经纪公司
  char m_AllowName[64 + 1];        // 业务显示名称，UI 用
  char m_AllowNameEn[64 + 1];      // 业务显示名称EN，UI 用
  char m_Abbr[64 + 1];             // 英文简称，用于界面显示
  char m_BusinessAllowId[32 + 1];  // 业务ID
  char m_BusinessName[32 + 1];     // 业务名称
  char m_BusinessCode[32 + 1];     // 业务代码 BOND/IRS...
  char m_BusinessLevel[32 + 1];    // 业务基本
  /*"业务级别"IRS1","实时"
  "IRS2","实时无备注"
  "IRS3","价格拉宽1bp"
  "IRS4","价格拉宽2bp"
  "IRS5","价格拉宽3bp"
  "IRS6","价格拉宽4bp"
  "IRS7","价格拉宽5bp"
  空，则不需要该信息*/
  int m_Status_C;                                // 用户机构状态
  int m_Status_T;                                // 交易员状态
  int m_Status_B;                                // Broker审核状态
  bool m_bApplyed;                               // 已申请标签
  char m_UserName[64];                           // 未通过时联系人帐号
  char m_ContactName[32];                        // 未通过时联系人
  char m_ContactTEL[32];                         // 未通过时联系人电话
  char m_Email[64];                              // 未通过时联系人Email
  std::list<xQBAuthorityBroker_c> m_BrokerList;  // broker 联系人列表
  // std::list<xLevelItem_c> m_ItemList;
  // // 拉点详情

  xQBAuthorityBusiness_c() {
    m_BrokerID[0] = '\0';
    m_BrokerName[0] = '\0';
    m_CompanyType[0] = '\0';
    m_AllowName[0] = '\0';
    m_AllowNameEn[0] = '\0';
    m_Abbr[0] = '\0';
    m_BusinessAllowId[0] = '\0';
    m_BusinessName[0] = '\0';
    m_BusinessCode[0] = '\0';
    m_BusinessLevel[0] = '\0';
    m_Status_C = 0;
    m_Status_T = 0;
    m_Status_B = 0;
    m_bApplyed = false;

    m_ContactName[0] = '\0';
    m_ContactTEL[0] = '\0';
    m_UserName[0] = '\0';
    m_Email[0] = '\0';
  };
  void operator=(const xQBAuthorityBusiness_c& one) {
    memcpy(m_BrokerID, one.m_BrokerID, sizeof(m_BrokerID));
    memcpy(m_BrokerName, one.m_BrokerName, sizeof(m_BrokerName));
    memcpy(m_CompanyType, one.m_CompanyType, sizeof(m_CompanyType));
    memcpy(m_BusinessAllowId, one.m_BusinessAllowId, sizeof(m_BusinessAllowId));
    memcpy(m_AllowName, one.m_AllowName, sizeof(m_AllowName));
    memcpy(m_AllowNameEn, one.m_AllowNameEn, sizeof(m_AllowNameEn));
    memcpy(m_Abbr, one.m_Abbr, sizeof(m_Abbr));
    memcpy(m_BusinessName, one.m_BusinessName, sizeof(m_BusinessName));
    memcpy(m_BusinessCode, one.m_BusinessCode, sizeof(m_BusinessCode));
    memcpy(m_BusinessLevel, one.m_BusinessLevel, sizeof(m_BusinessLevel));
    m_Status_C = one.m_Status_C;
    m_Status_T = one.m_Status_T;
    m_Status_B = one.m_Status_B;
    m_bApplyed = one.m_bApplyed;
    memcpy(m_UserName, one.m_UserName, sizeof(m_UserName));
    memcpy(m_ContactName, one.m_ContactName, sizeof(m_ContactName));
    memcpy(m_ContactTEL, one.m_ContactTEL, sizeof(m_ContactTEL));
    memcpy(m_Email, one.m_Email, sizeof(m_Email));
    m_BrokerList.clear();
    for (std::list<xQBAuthorityBroker_c>::const_iterator it =
             one.m_BrokerList.begin();
         it != one.m_BrokerList.end(); it++) {
      m_BrokerList.push_back(*it);
    }
  };
};

class xQBAuthorityQueryAck_c {
 public:
  char m_UserId[32 + 1];    // 用户id，32UUID
  char m_OverSeaFlag[4];    // 海外版标志，1--国内，2--海外
  int m_AllowOpenQM;        // 启用QM标志
  int m_AllowAlltab;        // 启用All-tab
  int m_AllowMarketStream;  // 启用MarketStream
  std::list<xQBAuthorityBusiness_c> m_BusinessList;  // 业务列表
  std::list<xLevelItem_c> m_ItemList;                // 拉点详情
  xQBAuthorityQueryAck_c() {
    m_UserId[0] = '\0';
    m_OverSeaFlag[0] = '\0';
    m_AllowOpenQM = 0;
    m_AllowAlltab = 0;
    m_AllowMarketStream = 0;
  }
};

// E_FID_QB_USER_PERM_APPLY = 50145,			// Permission功能申请
// E_FID_QB_USER_PERM_APPLYSTATE_REQ = 50146,			//
// Permission功能申请状态查询

//-----------------------------------------------------------------------------------
// E_FID_QB_USER_SPONSORS = 50147,            // 请求QB赞助机构
// 请求：
typedef struct xQBUserSponsorsReq_t {
  char m_UserId[32 + 1];     // QB用户id
  char m_CompanyID[32 + 1];  // QB用户机构id
  xQBUserSponsorsReq_t() { memset(this, 0, sizeof(xQBUserSponsorsReq_t)); };
} QBUserSponsorsReq, *PQBUserSponsorsReq;

// 应答：
typedef struct xQBUserSponsorsAct_t {
  char m_companyId[32 + 1];  // 赞助机构id
  char m_name[128 + 1];      // 赞助机构名称
  char m_shortName[64 + 1];  // 赞助机构简称，显示机构
  char m_fullName[128 + 1];  // 赞助机构全称
  char m_startDate[16 + 1];  // 赞助起始日
  char m_endDate[16 + 1];    // 赞助截止日
  xQBUserSponsorsAct_t() { memset(this, 0, sizeof(xQBUserSponsorsAct_t)); };
} QBUserSponsorsAct, *PQBUserSponsorsAct;

//-----------------------------------------------------------------------------------
// E_FID_QB_USER_WEBOPTOIN_REQ = 50148,			// 请求用户配置，web
// url等 请求
typedef struct xQBUserWebOptionReq_t {
  char m_UserID[32 + 1];     // QB用户id
  char m_CompanyID[32 + 1];  // QB用户机构id
  char m_ServerID[32 + 1];   // 服务器ID，（专线，非专线，其他）
  xQBUserWebOptionReq_t() { memset(this, 0, sizeof(xQBUserWebOptionReq_t)); };
} QBUserWebOptionReq, *PQBUserWebOptionReq;

// 应答：
typedef struct xQBUserWebOptionAck_c {
  char m_UserId[32 + 1];  // 用户id，32UUID
  std::map<std::string, std::string> m_Options;
  xQBUserWebOptionAck_c() { memset(m_UserId, 0, 33); };
} QBUserWebOptionAck, *PQBUserWebOptionAck;

//-----------------------------------------------------------------------------------
// E_FID_QB_USER_PERMISSION_REQ				= 50149,
// // QB 查询 Permission 权限，king 请求同E_FID_QB_AUTHORITY_QUERY_NEW_REQ
// = 50155 应答：
typedef struct _tag_QBUserPermissionItem {
  char m_Index[64];
  char m_Value[16];
  _tag_QBUserPermissionItem() {
    memset(this, 0, sizeof(_tag_QBUserPermissionItem));
  };
} QBUserPermissionItem;

class xQBUserPermissionAck_c {
 public:
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  std::list<QBUserPermissionItem> m_List;
  xQBUserPermissionAck_c() {
    memset(m_UserId, 0, 33);
    memset(m_CompanyId, 0, 33);
  };
};

//-----------------------------------------------------------------------------------
// E_FID_QB_AUTHORITY_APPLY_REQ				= 50118,
// // QB 权限申请
typedef struct xQBAuthorityApplyReq_t {
  char m_UserId[32 + 1];           // 用户id，32UUID
  char m_BusinessAllowId[32 + 1];  // 业务ID
  char m_BrokerID[32 + 1];         // 经纪公司ID
  xQBAuthorityApplyReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_BusinessAllowId, 0, sizeof(m_BusinessAllowId));
    memset(m_BrokerID, 0, sizeof(m_BrokerID));
  }
} QBAuthorityApplyReq_t, *PQBAuthorityApplyReq_t;

class xQBAuthorityApplyAck_c {
 public:
  char m_BrokerID[32 + 1];         // 经纪公司ID
  char m_BusinessAllowId[32 + 1];  // 业务ID
  char m_BusinessLevel[32];        // 注释见50120
  int m_Status_C;  // 用户机构状态，50118 应答不用判断，50119推送应答需判断
  int m_Status_T;          // 交易员状态
  int m_Status_B;          // Broker审核状态
  char m_ContactName[32];  // 未通过时联系人
  char m_ContactTEL[32];   // 未通过时联系人电话

  std::list<xQBAuthorityBroker_c> m_BrokerList;  // broker 联系人列表
  xQBAuthorityApplyAck_c() : m_Status_C(0), m_Status_T(0), m_Status_B(0) {
    memset(m_BrokerID, 0, sizeof(m_BrokerID));
    memset(m_BusinessAllowId, 0, sizeof(m_BusinessAllowId));
    memset(m_BusinessLevel, 0, sizeof(m_BusinessLevel));
    memset(m_ContactName, 0, sizeof(m_ContactName));
    memset(m_ContactTEL, 0, sizeof(m_ContactTEL));
  }
};

class xQBAuthorityApplyAckList_c {
 public:
  char m_UserId[32 + 1];  // 用户id，32UUID
  std::list<xQBAuthorityApplyAck_c> m_List;
  xQBAuthorityApplyAckList_c() { m_UserId[0] = '\0'; }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_AUTHORITY_APPROVED_PUSH			= 50119,
// // QB 权限批准推送 应答同50118

//-----------------------------------------------------------------------------------
// E_FID_QB_MOBILE_BROKER_ACTIVATE				= 50673,
// //手机扫码激活经纪商行情 请求
struct xQBMobileBrokerActivateReq_t {
 public:
  char m_UserName[64];     // 用户名
  char m_UserID[64];       // 用户ID
  char m_ActivateKey[64];  // 动态码，5分钟失效
  time_t m_time;
  xQBMobileBrokerActivateReq_t() {
    memset(this, 0, sizeof(xQBMobileBrokerActivateReq_t));
  };
};

//-----------------------------------------------------------------------------------
// E_FID_QB_EXPIRATION_BUY_APPLY_REQ			= 50674,
// //到期提醒-点击购买正式版 请求
struct xQBExpirationBuyApplyReq_t {
 public:
  char m_UserId[32 + 1];       // 用户id
  char m_UserAccount[32 + 1];  // 登录名
  xQBExpirationBuyApplyReq_t() {
    memset(this, 0, sizeof(xQBExpirationBuyApplyReq_t));
  }
};
// 应答，无包体，retcode = 0表示成功

//-----------------------------------------------------------------------------------
// E_FID_QB_KICK_MULTI_BROKER				= 51998,
// // 多终端登录，踢经济商行情 E_FID_QB_KICK_MULTI_TERMINAL
// = 51999,			// 多终端登录，踢下线
class xQBKickMultiTerminalInfo_c {
 public:
  char m_UserName[64];      // 动态码，UUID
  char m_UserID[64];        // 用户ID
  char m_TerminalType[32];  // 终端类型
  int m_Type;               // 互踢类型，0 = 经纪商行情，待增加
  time_t m_time;
  xQBKickMultiTerminalInfo_c() : m_time(0) {
    memset(m_UserName, 0, sizeof(m_UserName));
    memset(m_UserID, 0, sizeof(m_UserID));
    memset(m_TerminalType, 0, sizeof(m_TerminalType));
    m_Type = 0;
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_BROKER_PRICE_REGISTER			= 50130,
// // 经纪商行情注册 E_FID_QB_BROKER_PRICE_UNREGISTER			= 50131,
// // 经纪商行情取消注册
typedef struct xQBBrokerPriceRegReq_t {
  char m_UserId[32 + 1];                 // 用户唯一ID
  int m_ver;                             // 版本号
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
  xQBBrokerPriceRegReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    m_ver = -1;
  }
} QBBrokerPriceRegReq_t, *PQBBrokerPriceRegReq_t;
// 无应答

//-----------------------------------------------------------------------------------
// E_FID_QB_BONDCOP_ACCOUNT_MANAGER_REQ		= 50144, //
// 请求机构二级联系人，宏源热卖 请求应答见"SSIDBModel.h"

//-----------------------------------------------------------------------------------
// E_FID_QB_INDICATIVE_PRICE_REQ				= 50150,
// //请求海外版指导价 请求同E_FID_QB_BEST_PRICE_REQ	 50006
class xQBIndicativePriceUnit_c {
 public:
  char m_bondkey[32 + 1];  // 产品ID== bondkey
  char m_listedmarket[8];  // 市场代码
  char m_symbol
      [4];  // bid/ask标识
            // 1--bid,-1,ofr，0--表示确却双边报价或者净价，在客户端不显示bid/ofr图标
  char m_price[12];        // 参考价-净价
  char m_yield[12];        // 参考价-收益率
  char m_clean_price[12];  // 参考价-净价
  char m_company_id[4];    // 经纪公司ID
  time_t m_modify_time;    // datetime
  int m_version;  // 版本索引，每个公司唯一自增，从0开始
  xQBIndicativePriceUnit_c() : m_modify_time(0), m_version(0) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
    memset(m_symbol, 0, sizeof(m_symbol));
    memset(m_price, 0, sizeof(m_price));
    memset(m_yield, 0, sizeof(m_yield));
    memset(m_clean_price, 0, sizeof(m_clean_price));
    memset(m_company_id, 0, sizeof(m_company_id));
  }
  const bool operator<(const xQBIndicativePriceUnit_c& obj) const {
    return (m_modify_time > obj.m_modify_time);
  }
};

class xQBIndicativePriceListAck_c {
 public:
  std::list<xQBIndicativePriceUnit_c> m_List;  // 指导价列表数据
  char m_BusinessCode[32 + 1];  // Broker权限，BOND，NCD，空=全
  xQBIndicativePriceListAck_c() {
    memset(m_BusinessCode, 0, sizeof(m_BusinessCode));
  };
};
//-----------------------------------------------------------------------------------
// E_FID_QB_MARKET_STREAM_OVERSEAS_REQ			= 50151,
// //请求海外版市场报价 基本版 请求同E_FID_QB_MARKET_STREAM_REQ
// 应答同E_FID_QB_INDICATIVE_PRICE_REQ

//-----------------------------------------------------------------------------------
// E_FID_QB_MARKET_STREAM_EX_OVERSEAS_REQ		= 50152,
// //请求海外版市场报价 高级版 请求同E_FID_QB_MARKET_STREAM_EX_REQ
// 应答同E_FID_QB_INDICATIVE_PRICE_REQ

//-----------------------------------------------------------------------------------
// E_FID_QB_MARKET_STREAM_BY_GROUP_OVERSEA_QRY		= 50159,
// //QB 海外版请求Marketstream信息(按"关注组"查询)
// 请求同E_FID_QB_MARKET_STREAM_HIS_QRY3
// 应答同E_FID_QB_INDICATIVE_PRICE_REQ

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CPI_QRY						= 50160,
// //宏观经济，CPI
typedef struct xQBMacroReq_t {
  time_t m_begin;
  time_t m_end;
  xQBMacroReq_t() : m_begin(0), m_end(0) {}
} QBMacroReq_t, *PQBMacroReq_t;

class xCPIUnit_c {
 public:
  char m_CPI[12];        // CPI(同比)
  char m_CPI_food[12];   // CPI-食品(同比)
  char m_CPI2[12];       // CPI(环比)
  char m_CPI_food2[12];  // CPI-食品(环比)
  char m_avg[12];        // CPI月度环比均值(5Y)
  time_t m_time;
  xCPIUnit_c() : m_time(0) {
    memset(m_CPI, 0, sizeof(m_CPI));
    memset(m_CPI_food, 0, sizeof(m_CPI_food));
    memset(m_CPI2, 0, sizeof(m_CPI2));
    memset(m_CPI_food2, 0, sizeof(m_CPI_food2));
    memset(m_avg, 0, sizeof(m_avg));
  }
};

class xCPIList_c {  // 宏观列表
 public:
  std::list<xCPIUnit_c> m_List;  // 对应值列表
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_FOOD_QRY						= 50161,
// //宏观经济，食品 请求同50160
class xCPIFoodUnit_c {
 public:
  char m_Meet[12];       // 肉禽及其制品
  char m_Egg[12];        // 蛋
  char m_Aquatic[12];    // 水产品
  char m_Vegetable[12];  // 鲜菜
  time_t m_time;
  xCPIFoodUnit_c() : m_time(0) {
    memset(m_Meet, 0, sizeof(m_Meet));
    memset(m_Egg, 0, sizeof(m_Egg));
    memset(m_Aquatic, 0, sizeof(m_Aquatic));
    memset(m_Vegetable, 0, sizeof(m_Vegetable));
  }
};

class xCPIFoodList_c {  // 宏观列表
 public:
  std::list<xCPIFoodUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_NON_FOOD_QRY					= 50162,
// //宏观经济，非食品 请求同50160
class xCPINonFoodUnit_c {
 public:
  char m_Cloth[12];       // 衣着
  char m_Appliances[12];  // 家庭设备用品及维修服务
  char m_Medical[12];     // 医疗保健和个人用品
  char m_Traffic[12];     // 交通和通信
  char m_Culture[12];     // 娱乐教育文化用品及服务
  time_t m_time;
  xCPINonFoodUnit_c() : m_time(0) {
    memset(m_Cloth, 0, sizeof(m_Cloth));
    memset(m_Appliances, 0, sizeof(m_Appliances));
    memset(m_Medical, 0, sizeof(m_Medical));
    memset(m_Traffic, 0, sizeof(m_Traffic));
    memset(m_Culture, 0, sizeof(m_Culture));
  }
};

class xCPINonFoodList_c {  // 宏观列表
 public:
  std::list<xCPINonFoodUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_INDUSTRY_QRY					= 50163,
// //宏观经济，工业增加值 请求同50160
class xIndustryUnit_c {
 public:
  char m_AddRatio[12];   // 工业增加值（同比）
  char m_Inventory[12];  // 工业库存（累计同比）
  char m_Power[12];      // 用电量（同比）
  char m_Light[12];      // 轻工业增加值（同比）
  char m_Heavy[12];      // 重工业增加值（同比）
  time_t m_time;
  xIndustryUnit_c() : m_time(0) {
    memset(m_AddRatio, 0, sizeof(m_AddRatio));
    memset(m_Inventory, 0, sizeof(m_Inventory));
    memset(m_Power, 0, sizeof(m_Power));
    memset(m_Light, 0, sizeof(m_Light));
    memset(m_Heavy, 0, sizeof(m_Heavy));
  }
};

class xIndustryList_c {  // 宏观列表
 public:
  std::list<xIndustryUnit_c> m_List;  //
};
//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_INDUSTRY_INDUSTRY_QRY		= 50164,
// //宏观经济，工业增加值,按行业 请求同50160
class xInduInduUnit_c {
 public:
  char m_Val1[12];  // 煤炭开采和洗选业
  char m_Val2[12];  // 石油和天然气开采业
  char m_Val3[12];  // 黑色金属矿采选业
  char m_Val4[12];  // 有色金属矿采选业
  char m_Val5[12];  // 非金属矿采选业

  char m_Val6[12];   // 石油加工、炼焦和核燃料加工业
  char m_Val7[12];   // 黑色金属冶炼及压延加工业
  char m_Val8[12];   // 有色金属冶炼及压延加工业
  char m_Val9[12];   // 化学原料及化学制品制造业
  char m_Val10[12];  // 医药制造业

  char m_Val11[12];  // 金属制品业
  char m_Val12[12];  // 通用设备制造业
  char m_Val13[12];  // 专用设备制造业
  char m_Val14[12];  // 汽车制造业
  char m_Val15[12];  // 铁路、船舶、航空航天和其他设备制造业

  char m_Val16[12];  // 电气机械和器材制造业
  char m_Val17[12];  // 计算机、通讯和其他电子设备制造业

  time_t m_time;

  xInduInduUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
    memset(m_Val6, 0, sizeof(m_Val6));
    memset(m_Val7, 0, sizeof(m_Val7));
    memset(m_Val8, 0, sizeof(m_Val8));
    memset(m_Val9, 0, sizeof(m_Val9));
    memset(m_Val10, 0, sizeof(m_Val10));
    memset(m_Val11, 0, sizeof(m_Val11));
    memset(m_Val12, 0, sizeof(m_Val12));
    memset(m_Val13, 0, sizeof(m_Val13));
    memset(m_Val14, 0, sizeof(m_Val14));
    memset(m_Val15, 0, sizeof(m_Val15));
    memset(m_Val16, 0, sizeof(m_Val16));
    memset(m_Val17, 0, sizeof(m_Val17));
  }
};

class xInduInduList_c {  // 宏观列表
 public:
  std::list<xInduInduUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_INDUSTRY_AREA_QRY			= 50165,
// //宏观经济，工业增加值,按地区 请求同50160
class xInduAreaUnit_c {
 public:
  char m_East[12];    // 东部地区
  char m_Middle[12];  // 中部地区
  char m_West[12];    // 西部地区
  time_t m_time;
  xInduAreaUnit_c() : m_time(0) {
    memset(m_East, 0, sizeof(m_East));
    memset(m_Middle, 0, sizeof(m_Middle));
    memset(m_West, 0, sizeof(m_West));
  }
};

class xInduAreaList_c {  // 宏观列表
 public:
  std::list<xInduAreaUnit_c> m_List;  //
};
//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_INDUSTRY_PRODUCT_QRY			= 50166,
// //宏观经济，工业增加值,按产品 请求同50160
class xInduProductUnit_c {
 public:
  char m_Steel[12];       // 钢材
  char m_Nonferrous[12];  // 十种有色金属
  char m_Cement[12];      // 水泥
  char m_Oil[12];         // 天然原油
  char m_Ethylene[12];    // 乙烯
  char m_Car[12];         // 汽车
  time_t m_time;
  xInduProductUnit_c() : m_time(0) {
    memset(m_Steel, 0, sizeof(m_Steel));
    memset(m_Nonferrous, 0, sizeof(m_Nonferrous));
    memset(m_Cement, 0, sizeof(m_Cement));
    memset(m_Oil, 0, sizeof(m_Oil));
    memset(m_Ethylene, 0, sizeof(m_Ethylene));
    memset(m_Car, 0, sizeof(m_Car));
  }
};

class xInduProductList_c {  // 宏观列表
 public:
  std::list<xInduProductUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_EFFICIENCY_QRY		= 50167,
// //宏观经济，工业企业效益 请求同50160
class xEfficiencyUnit_c {
 public:
  char m_Profit[12];          // 利润-同比（%）
  char m_Pft_Cumulative[12];  // 利润累计-同比（%）
  char m_M_Income[12];        // 主营业务收入-同比（%）
  char m_M_Cost[12];          // 主营业务成本-同比（%）
  char m_Pft_C_Ratio[12];     // 利润率贡献（%）
  char m_M_tax[12];           // 主营业务税金及附加-同比（%）

  char m_Sell_Fee[12];   // 销售费用-同比（%）
  char m_Mg_Fee[12];     // 管理费用-同比（%）
  char m_Fin_Fee[12];    // 财务费用-同比（%）
  char m_Inventory[12];  // 库存-同比（%）
  char m_Pft_Year[12];   // 利润率-同比(%)
  time_t m_time;
  xEfficiencyUnit_c() : m_time(0) {
    memset(m_Profit, 0, sizeof(m_Profit));
    memset(m_Pft_Cumulative, 0, sizeof(m_Pft_Cumulative));
    memset(m_M_Income, 0, sizeof(m_M_Income));
    memset(m_M_Cost, 0, sizeof(m_M_Cost));
    memset(m_Pft_C_Ratio, 0, sizeof(m_Pft_C_Ratio));
    memset(m_M_tax, 0, sizeof(m_M_tax));
    memset(m_Sell_Fee, 0, sizeof(m_Sell_Fee));
    memset(m_Mg_Fee, 0, sizeof(m_Mg_Fee));
    memset(m_Fin_Fee, 0, sizeof(m_Fin_Fee));
    memset(m_Inventory, 0, sizeof(m_Inventory));
    memset(m_Pft_Year, 0, sizeof(m_Pft_Year));
  }
};

class xEfficiencyList_c {  // 宏观列表
 public:
  std::list<xEfficiencyUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_EFFICIENCY_PROFIT_QRY		= 50168,
// //宏观经济，工业企业效益,利润总额 请求同50160
class xEfficPftUnit_c {
 public:
  char m_Val1[12];  // 煤炭开采和洗选业
  char m_Val2[12];  // 石油和天然气开采业
  char m_Val3[12];  // 黑色金属矿采选业
  char m_Val4[12];  // 有色金属矿采选业
  char m_Val5[12];  // 非金属矿采选业
  char m_Val6[12];  // 黑色金属冶炼及压延加工业

  char m_Val7[12];   // 有色金属冶炼及压延加工业
  char m_Val8[12];   // 金属制品业
  char m_Val9[12];   // 通用设备制造业
  char m_Val10[12];  // 汽车制造业
  char m_Val11[12];  // 铁路、船舶、航空航天和其他运输设备制造业
  char m_Val12[12];  // 电器机械和器材制造业
  time_t m_time;
  xEfficPftUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
    memset(m_Val6, 0, sizeof(m_Val6));
    memset(m_Val7, 0, sizeof(m_Val7));
    memset(m_Val8, 0, sizeof(m_Val8));
    memset(m_Val9, 0, sizeof(m_Val9));
    memset(m_Val10, 0, sizeof(m_Val10));
    memset(m_Val11, 0, sizeof(m_Val11));
    memset(m_Val12, 0, sizeof(m_Val12));
  }
};

class xEfficPftList_c {  // 宏观列表
 public:
  std::list<xEfficPftUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_QRY					= 50169,
// //宏观经济，货币概览 请求同50160
class xCurrencyUnit_c {
 public:
  char m_Val1[12];  // Δ财政存款
  char m_Val2[12];  // Δ外汇（货币当局）
  char m_Val3[12];  // 净投放
  char m_Val4[12];  // ΔM0与库存现金
  char m_Val5[12];  // Δ法定存准
  char m_Val6[12];  // 超储率

  time_t m_time;
  xCurrencyUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
    memset(m_Val6, 0, sizeof(m_Val6));
  }
};

class xCurrencyList_c {  // 宏观列表
 public:
  std::list<xCurrencyUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_FIN_DEPOSIT_QRY		= 50170,
// //宏观经济，货币概览，财政存款 请求同50160
class xCurFinDptUnit_c {
 public:
  char m_Val1[12];  // 政府存款（货币当局）
  char m_Val2[12];  // 财政存款（金融机构）
  char m_Val3[12];  // 财政收入
  char m_Val4[12];  // 财政支出
  char m_Val5[12];  // 财政收支差额
  char m_Val6[12];  // 财政存款变动=财政存款（金融机构）的当月-上月,再除以100
  time_t m_time;
  xCurFinDptUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
    memset(m_Val6, 0, sizeof(m_Val6));
  }
};

class xCurFinDptList_c {  // 宏观列表
 public:
  std::list<xCurFinDptUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_FX_FUNDS_QRY		= 50171,
// //宏观经济，货币概览,外汇占款 请求同50160
class xCurFxFundsUnit_c {
 public:
  char m_Val1[12];  // 外汇（货币当局）
  char m_Val2[12];  // Δ外汇（货币当局）
  char m_Val3[12];  // 外汇占款（金融当局）
  char m_Val4[12];  // Δ外汇占款（金融当局）

  time_t m_time;
  xCurFxFundsUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
  }
};

class xCurFxFundsList_c {  // 宏观列表
 public:
  std::list<xCurFxFundsUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_OP_QRY				= 50172,
// //宏观经济，货币概览,公开市场操作 请求同50160
class xCurOPUnit_c {
 public:
  char m_Val1[12];  // 投放（亿）
  char m_Val2[12];  // 回笼（亿）
  char m_Val3[12];  // 净投放（亿）

  time_t m_time;
  xCurOPUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
  }
};

class xCurOPList_c {  // 宏观列表
 public:
  std::list<xCurOPUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_MO_CASH_QRY			= 50173,
// //宏观经济，货币概览,M0与库存现金 请求同50160
class xCurMoUnit_c {
 public:
  char m_Val1[12];  // M0
  char m_Val2[12];  // ΔM0
  char m_Val3[12];  // 库存现金
  char m_Val4[12];  // Δ库存现金
  char m_Val5[12];  // ΔM0与库存现金

  time_t m_time;
  xCurMoUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
  }
};

class xCurMoList_c {  // 宏观列表
 public:
  std::list<xCurMoUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MACRO_CURRENCY_DEPOSIT_RATIO_QRY	= 50174,
// //宏观经济，货币概览,存款与存准 请求同50160
class xCurDptRatioUnit_c {
 public:
  char m_Val1[12];  // 存款
  char m_Val2[12];  // 一般存款
  char m_Val3[12];  // 加权法定存准率
  char m_Val4[12];  // 法定存准
  char m_Val5[12];  // Δ法定存准

  time_t m_time;
  xCurDptRatioUnit_c() : m_time(0) {
    memset(m_Val1, 0, sizeof(m_Val1));
    memset(m_Val2, 0, sizeof(m_Val2));
    memset(m_Val3, 0, sizeof(m_Val3));
    memset(m_Val4, 0, sizeof(m_Val4));
    memset(m_Val5, 0, sizeof(m_Val5));
  }
};

class xCurDptRatioList_c {  // 宏观列表
 public:
  std::list<xCurDptRatioUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_SHFI_SINGLE_QUOTE_REQ				= 50421
// // 查询上证固收，五档 E_FID_QB_SHFI_SINGLE_QUOTE_PUSH
// = 50422,			// 个券详情-上证固收，报价、5档，推送
// E_FID_QB_SHFI_SINGLE_QUOTE_PUSH_CANCEL		= 50423,
// // 个券详情-上证固收，报价、5档，取消推送

//	推送，取消推送 与 请求包 一致
//	取消推送，无应答包体

// 请求:
typedef struct xQBSHFIQuoteQuery_t {
  char m_BondKey[32 + 1];  // bondKey;				唯一
  char m_ListedMarket[8];  // 市场代码
  char m_BrokerID[8];      // BrokerID, SSET
  xQBSHFIQuoteQuery_t() { clear(); }
  void clear() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    __FIELDCOPY__(m_BrokerID, "SSET");
  }
  bool operator==(const xQBSHFIQuoteQuery_t& right) {
    return strcmp(m_BondKey, right.m_BondKey) == 0 &&
           strcmp(m_ListedMarket, right.m_ListedMarket) == 0 &&
           strcmp(m_BrokerID, right.m_BrokerID) == 0;
  }
  bool operator!=(const xQBSHFIQuoteQuery_t& right) {
    return !(*this == right);
  }
} QBSHFIQuoteQuery_t, *PQBSHFIQuoteQuery_t;

// 应答:
typedef struct xQBSHFIQuote5 {
  char m_Yield[PRICE_LEN];  // 买/卖一 收益率
  char m_Price[PRICE_LEN];  // 买/卖一 原始价
  char m_Vol[VOLUME_LEN];   // 买/卖一 量
  char m_ExerciseFlag[4];  // 用来确定收益率类型：0 - 行权收益率； 1- 到期收益率
  char m_Institution[64];  // 买/卖方 机构
  xQBSHFIQuote5() { memset(this, 0, sizeof(xQBSHFIQuote5)); }
} QBSHFIQuote5;

class xQBSHFIQuoteUnit_c {
 public:
  char m_BondKey[32 + 1];  // bondKey;				唯一
  char m_ListedMarket[8];  // 市场代码
  time_t m_Time;           // 精确到毫秒
  int m_Index;             // 请求序列的开始，0 从最早开始
  char m_BrokerID[8];      // SSET
  QBSHFIQuote5 m_Bid;
  QBSHFIQuote5 m_Ofr;

  xQBSHFIQuoteUnit_c() { clear(); }
  void clear() { memset(this, 0, sizeof(xQBSHFIQuoteUnit_c)); }
};

class xQBSHFIQuoteList_c {
 public:
  std::list<xQBSHFIQuoteUnit_c> m_List;
};

//-----------------------------------------------------------------------------------
// E_FID_QB_SHFI_SINGLE_MARTETSTREAM_REQ			= 50424,
// // 个券详情-上证固收，请求MarketStream 请求:
typedef struct xQBSHFIMarketStreamReq_t {
  char m_BondKey[32 + 1];  // key
  char m_ListedMarket[8];  // 市场代码
  char m_BrokerID[8];      // BrokerID, SSET
  int m_IndexFrom;         // 请求序列的开始，0 从最早开始
  int m_IndexTo;           // 请求序列的结束，-1到最新

  xQBSHFIMarketStreamReq_t() { clear(); }
  void clear() {
    m_IndexFrom = 0;
    m_IndexTo = 0;
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    __FIELDCOPY__(m_BrokerID, "SSET");
  }
  bool operator==(const xQBSHFIMarketStreamReq_t& right) {
    return strcmp(m_BondKey, right.m_BondKey) == 0 &&
           strcmp(m_ListedMarket, right.m_ListedMarket) == 0 &&
           strcmp(m_ListedMarket, right.m_ListedMarket) == 0;
  }
  bool operator!=(const xQBSHFIMarketStreamReq_t& right) {
    return !(*this == right);
  }

} QBSHFIMarketStreamReq_t, *PQBSHFIMarketStreamReq_t;
// 应答同50930 xQBMarketStreamList_c

//-----------------------------------------------------------------------------------------------------------------------
// 	E_FID_QB_SHFI_SINGLE_DEAL_REQ				= 50425,
// // 个券详情-上证固收，成交，请求
//	E_FID_QB_SHFI_SINGLE_DEAL_PUSH				= 50426,
//// 个券详情-上证固收，成交，推送 	E_FID_QB_SHFI_SINGLE_DEAL_PUSH_CANCEL
//= 50427,			// 个券详情-上证固收，成交，取消推送
//  成交50425和50426请求与推送 和 50424请求包一致

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_QUOTE_QUERY						= 50181,
// // 查询交易所行情,五档
typedef struct xQBExQuoteQuery_t {
  std::list<TW_BOND> m_Bond;  // 债券列表
} QBExQuoteQuery_t, *PQBExQuoteQuery_t;

typedef struct xQBExQuote5 {
  char m_YTE[PRICE_LEN];       // 买一 行权收益率 yield to exercise
  char m_YTC[PRICE_LEN];       // 买一 行权收益率 yield to cal
  char m_YTP[PRICE_LEN];       // 买一 行权收益率 yield to put
  char m_YTM[PRICE_LEN];       // 买一 到期收益率
  char m_NetPrice[PRICE_LEN];  // 买一 净价
  char m_Vol[VOLUME_LEN];      // 买一 量
  xQBExQuote5() { memset(this, 0, sizeof(xQBExQuote5)); }
} QBExQuote5;

class xQBExQuoteUnit_c {
 public:
  char m_BondKey[32 + 1];    // bondKey;				唯一
  char m_ListedMarket[8];    // 市场代码
  xQBExQuote5 m_Quote5[10];  // 卖五~卖一，买一~买五，固定顺序
  time_t m_time;             // 精确到秒，

  // 	char					m_BidYield1[PRICE_LEN];
  // //买一 收益率 	char					m_BidYTC1[PRICE_LEN];
  // //买一 收益率 yield to cal 	char
  // m_BidYTP1[PRICE_LEN];						//买一
  // 收益率 yield to put 	char
  // m_BidClean1[PRICE_LEN];						//买一
  // 净价 	char					m_BidVol1[VOLUME_LEN];
  // //买一 量 	char					m_BidYield2[PRICE_LEN];
  // 	char					m_BidClean2[PRICE_LEN];
  // 	char					m_BidYTC2[PRICE_LEN];
  // 	char					m_BidYTP2[PRICE_LEN];
  // 	char					m_BidVol2[VOLUME_LEN];
  // 	char					m_BidYield3[PRICE_LEN];
  // 	char					m_BidYTC3[PRICE_LEN];
  // 	char					m_BidYTP3[PRICE_LEN];
  // 	char					m_BidClean3[PRICE_LEN];
  // 	char					m_BidVol3[VOLUME_LEN];
  // 	char					m_BidYield4[PRICE_LEN];
  // 	char					m_BidYTC4[PRICE_LEN];
  // 	char					m_BidYTP4[PRICE_LEN];
  // 	char					m_BidClean4[PRICE_LEN];
  // 	char					m_BidVol4[VOLUME_LEN];
  // 	char					m_BidYield5[PRICE_LEN];
  // //买5 收益率 	char					m_BidYTC5[PRICE_LEN];
  // 	char					m_BidYTP5[PRICE_LEN];
  // 	char					m_BidClean5[PRICE_LEN];
  // //买5 净价 	char					m_BidVol5[VOLUME_LEN];
  // //买5 量
  //
  // 	char					m_OfrYield1[PRICE_LEN];
  // //卖一 收益率 	char					m_OfrYTC1[PRICE_LEN];
  // //卖一 收益率 yield to cal 	char
  // m_OfrYTP1[PRICE_LEN];						//卖一
  // 收益率 yield to put 	char
  // m_OfrClean1[PRICE_LEN];						//卖一
  // 净价 	char					m_OfrVol1[VOLUME_LEN];
  // //卖一 量 	char					m_OfrYield2[PRICE_LEN];
  // 	char					m_OfrYTC2[PRICE_LEN];
  // 	char					m_OfrYTP2[PRICE_LEN];
  // 	char					m_OfrClean2[PRICE_LEN];
  // 	char					m_OfrVol2[VOLUME_LEN];
  // 	char					m_OfrYield3[PRICE_LEN];
  // 	char					m_OfrYTC3[PRICE_LEN];
  // 	char					m_OfrYTP3[PRICE_LEN];
  // 	char					m_OfrClean3[PRICE_LEN];
  // 	char					m_OfrVol3[VOLUME_LEN];
  // 	char					m_OfrYield4[PRICE_LEN];
  // 	char					m_OfrYTC4[PRICE_LEN];
  // 	char					m_OfrYTP4[PRICE_LEN];
  // 	char					m_OfrClean4[PRICE_LEN];
  // 	char					m_OfrVol4[VOLUME_LEN];
  // 	char					m_OfrYield5[PRICE_LEN];
  // //卖5 收益率 	char					m_OfrYTC5[PRICE_LEN];
  // 	char					m_OfrYTP5[PRICE_LEN];
  // 	char					m_OfrClean5[PRICE_LEN];
  // //卖5 净价 	char					m_OfrVol5[VOLUME_LEN];
  // //卖5 量

  xQBExQuoteUnit_c() : m_time(0) {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
  }
};

class xQBExQuoteList_c {  // 行情列表
 public:
  std::list<xQBExQuoteUnit_c> m_List;  //
};

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_QUOTE_PUSH						= 50182,
// // 交易所行情推送，注册,五档 请求应答同50181
//

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_QUOTE_PUSH_CANCEL				= 50183,
// // 交易行情推送，注册取消,五档 请求同50181，无应答包体

//-----------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------
// E_FID_QB_EX_BEST_QUOTE_QUERY				= 50184,
// // 查询交易所行情,最优
typedef struct xQBQuoteQuery_t {
  std::list<TW_BOND> m_Bond;  // 债券列表
} QBQuoteQuery_t, *PQBQuoteQuery_t;
// 应答同 E_FID_QB_BEST_PRICE_PUSH_V2

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_BEST_QUOTE_PUSH					= 50185,
// // 交易所行情推送，注册,最优 请求应答同50184

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_BEST_QUOTE_PUSH_CANCEL			= 50186,
// // 交易行情推送，注册取消,最优 请求同50184，无应答

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_QUOTE_QUERY					= 50190,
// // 查询CFETS行情,最优  anson 请求应答同50184

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_QUOTE_PUSH					= 50191,
// // CFETS行情推送，注册,最优  anson 请求应答同50184

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_QUOTE_PUSH_CANCEL			= 50192,
// // CFETS行情推送，注册取消,最优  anson 请求同50184，无应答

////////////-----------------------------------------------------------------------------------
///////E_FID_QB_CFETS_DEAL_QUERY					= 50193,
///// 查询CFETS成交  anson
////////////请求50184,应答同E_FID_QB_MARKET_STREAM_REQ,50009

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_DEAL_PUSH					= 50194,
// // CFETS成交推送，注册  anson 请求同50184，，应答同 50009

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_DEAL_PUSH_CANCEL				= 50195,
// // CFETS成交推送，注册取消  anson 请求同50184，无应答

////////////-----------------------------------------------------------------------------------
////！！不用！！////////E_FID_QB_CFETS_MARKETSTREAM_QUERY
///= 50196,			// 查询CFETS的MARKETSTREAM anson
////////////请求同50184，,应答同 50009
//////////
//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_MARKETSTREAM_PUSH			= 50197,
// // CFETS的MARKETSTREAM推送，注册  anson 请求同50184,应答同 50009

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_MARKETSTREAM_PUSH_CANCEL		= 50198,
// // CFETS的MARKETSTREAM推送，注册取消 请求同50184，无应答

//////////////-----------------------------------------------------------------------------------
////////E_FID_QB_EX_DEAL_QUERY						= 50199,
///// 查询交易所成交  anson
//////////////请求50184,应答同E_FID_QB_MARKET_STREAM_REQ,50009

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_DEAL_PUSH						= 50200,
// // 交易所成交推送，注册  anson 请求同50184，，应答同 50009

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_DEAL_PUSH_CANCEL				= 50201,
// // 交易成交推送，注册取消 请求同50184，无应答

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_MARKETSTREAM_PUSH				= 50203,
// // 交易所MARKETSTREAM推送，注册  anson 请求同50184，应答同 50009

//-----------------------------------------------------------------------------------
// E_FID_QB_EX_MARKETSTREAM_PUSH_CANCEL		= 50204, //
// 交易所MARKETSTREAM推送，注册取消 请求同50184，无应答

//-----------------------------------------------------------------------------------
// E_FID_QB_HOLDING_CAL						= 50188,
// //持有期计算器
class xQBHoldingCal_c {
 public:
  // basics
  char m_bondKey[32 + 1];
  char m_listedMarket[8];
  char m_startDate[12];

  bool m_buyAndSell;  // true for buy then sell, false for sell and buy
  bool m_hasStartOption;
  bool m_hasEndOption;
  char m_endDate[12];
  double m_startFrontCommission;  // 期初前端手续费
  double m_endFrontCommission;    // 期末前端手续费
  double m_startBackCommission;   // 期初后端手续费
  double m_endBackCommission;     // 期末后端手续费

  // tax & cost
  double m_holdingCost;      // 融资成本， 若不考虑成本则为 0
  double m_businessTaxRate;  // 营业税率， 没有则赋值0
  double m_interestTaxRate;  // 利息税率， 没有则赋值0
  double m_businessTax;      // 营业税， 没有则赋值0
  double m_interestTax;      // 利息税， 没有则赋值0
  double m_totalTax;

  double m_interestIncomeTaxRate;  // 利息收入所得税率    在税费设置的弹出框里
  double m_businessIncomeTaxRate;  // 资本得利所得税率
  double m_interestVatRate;        // 利息收入增值税率
  double m_businessVatRate;        // 资本收入增值税率

  double m_businesValueAddedTax;  // 净值金额增值税额		计算结果的6/7/列
  double m_businesIncomeTax;       // 净值金额所得税额
  double m_interestValueAddedTax;  // 利息金额增值税额
  double m_interestIncomeTax;      // 利息金额所得税额
  double m_totalValueAddedTax;     // 总计增值税额
  double m_totalIncomeTax;         // 总计所得税额

  //
  double m_notional;  // 交易面额
  // start yields & prices
  double m_startYield;
  double m_startYieldToExecution;
  double m_startCleanPrice;
  double m_startFullPrice;
  double m_startAccruedAmount;
  // start yields & prices
  double m_endYield;
  double m_endYieldToExecution;
  double m_endCleanPrice;
  double m_endFullPrice;
  double m_endAccruedAmount;

  // start amount
  double m_startCleanAmount;  // 期初净值
  double m_startInterest;     // 期初利息金额
  double m_startTotal;        // 期初总金额

  // end amounts
  double m_endCleanAmount;
  double m_endInterest;
  double m_endTotal;

  // between
  double m_principalBetween;  // 期间还本
  double m_interestBetween;   // 期间利息收入
  double m_incomeBetween;     // 期间总收入
  // pretax
  double m_cleanAmountPnLPreTax;  // 税前净值变动
  double m_interestPnLPreTax;     // 税前利息收入
  double m_frontCommissionPreTax;
  double m_backCommissionPreTax;
  double m_pnLPretax;              // 税前总收入
  double m_yieldPreTax;            // 税前收益率
  double m_annualizedYieldPreTax;  // 税前年化收益率

  // after tax
  double m_cleanAmountPnLAT;   // 税后净值变动
  double m_interestPnLAT;      // 税后利息收入
  double m_frontCommissionAT;  // 前端费用
  double m_backCommissionAT;   // 后端费用
  double m_pnLAT;              // 税后收入（总计）
  // yield
  double m_yieldAT;             // 税后收益
  double m_annualizedYieldAT;   // 税后年化收益
  double m_netPnL;              // 扣除融资成本后净收入
  double m_netAnnualizedYield;  // 扣除融资成本后净年化收益率

  xQBHoldingCal_c()
      : m_buyAndSell(false),
        m_hasStartOption(false),
        m_hasEndOption(false),
        m_startFrontCommission(0),
        m_endFrontCommission(0),
        m_startBackCommission(0),
        m_endBackCommission(0),
        m_holdingCost(0),
        m_businessTaxRate(0),
        m_interestTaxRate(0),
        m_businessTax(0),
        m_interestTax(0),
        m_interestIncomeTaxRate(0)  //
        ,
        m_businessIncomeTaxRate(0),
        m_interestVatRate(0)  // 利息收入增值税率
        ,
        m_businessVatRate(0)  //
        ,
        m_interestIncomeTax(-999999),
        m_businesIncomeTax(-999999),
        m_businesValueAddedTax(-999999),
        m_interestValueAddedTax(-999999),
        m_totalIncomeTax(-999999),
        m_totalValueAddedTax(-999999)  //
        ,
        m_totalTax(-999999),
        m_notional(-999999),
        m_startYield(-999999),
        m_startYieldToExecution(-999999),
        m_startCleanPrice(-999999),
        m_startFullPrice(-999999),
        m_startAccruedAmount(-999999),
        m_endYield(-999999),
        m_endYieldToExecution(-999999),
        m_endCleanPrice(-999999),
        m_endFullPrice(-999999),
        m_endAccruedAmount(-999999),
        m_startCleanAmount(-999999),
        m_startInterest(-999999),
        m_startTotal(-999999),
        m_endCleanAmount(-999999),
        m_endInterest(-999999),
        m_endTotal(-999999),
        m_principalBetween(-999999),
        m_interestBetween(-999999),
        m_incomeBetween(-999999),
        m_cleanAmountPnLPreTax(-999999),
        m_interestPnLPreTax(-999999),
        m_frontCommissionPreTax(-999999),
        m_backCommissionPreTax(-999999),
        m_pnLPretax(-999999),
        m_yieldPreTax(-999999),
        m_annualizedYieldPreTax(-999999),
        m_cleanAmountPnLAT(-999999),
        m_interestPnLAT(-999999),
        m_frontCommissionAT(-999999),
        m_backCommissionAT(-999999),
        m_pnLAT(-999999),
        m_yieldAT(-999999),
        m_annualizedYieldAT(-999999),
        m_netPnL(-999999),
        m_netAnnualizedYield(-999999) {
    /*memset(this,0,((char *)(&(this->m_totalTax)) - (char *)this));;
    double * dp = &(this->m_totalTax);
    while (dp <= &(this->m_netAnnualizedYield) ){
    *dp = -999999;
    ++dp;
    }*/

    memset(m_bondKey, 0, sizeof(m_bondKey));
    memset(m_listedMarket, 0, sizeof(m_listedMarket));
    memset(m_startDate, 0, sizeof(m_startDate));
    memset(m_endDate, 0, sizeof(m_endDate));
  }
};
// 应答同请求，请求只填参数，应答填所有

//-----------------------------------------------------------------------------------
// E_FID_QB_INAV_QUERY							= 50205,
// // 查询查询iNAV价格  anson
typedef struct xQBINAVQuery_t {
  char m_Code[12];  // ETF 代码83199，82822，3199等
  xQBINAVQuery_t() { memset(m_Code, 0, sizeof(m_Code)); }
} QBINAVQuery_t, *PQBINAVQuery_t;

class xQBINAVPrice_c {
 public:
  char m_Code[12];  // ETF 代码83199，82822，3199等
  double m_Price;   // 价格
  time_t m_Time;
  // 行情时间
  xQBINAVPrice_c() : m_Price(0), m_Time(0) {
    memset(m_Code, 0, sizeof(m_Code));
  }
};

//-----------------------------------------------------------------------------------
// E_FID_QB_INAV_PUSH							= 50206,
// // iNAV价格推送，注册  anson 请求应答同50205
//-----------------------------------------------------------------------------------
// E_FID_QB_INAV_CANCEL							= 50207,
// // iNAV价格推送，注册取消 请求同50205,无应答

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_BEST_QUOTE_QUERY = 50208,			//
// 查询CFETS最优报价报价 add by lance 2018.3.28 请求应答同50190
// E_FID_QB_CFETS_BEST_QUOTE_PUSH = 50209,			//
// CFETS最优报价报价 注册 E_FID_QB_CFETS_BEST_QUOTE_PUSH_CANCEL = 50210,
// // CFETS最优报价报价 注销 请求应答同50191，50192

// E_FID_QB_CFETS_MARKETMAKER_QUOTE_QUERY = 50211,			//
// 查询CFETS点击成交报价 add by lance 2018.3.28 请求应答同50190
// E_FID_QB_CFETS_MARKETMAKER_QUOTE_PUSH = 50212,			//
// CFETS点击成交报价推送 注册 E_FID_QB_CFETS_MARKETMAKER_QUOTE_PUSH_CANCEL =
// 50213,			// CFETS点击成交报价推送 注销
// 请求应答同50191，50192

// E_FID_QB_CFETS_XBOND_QUOTE_QUERY = 50214,			// 查询CFETS
// X-BOND报价 add by lance 2018.3.28 请求应答同50190
// E_FID_QB_CFETS_XBOND_QUOTE_PUSH = 50215,			// CFETS
// X-BOND报价推送 注册 E_FID_QB_CFETS_XBOND_QUOTE_PUSH_CANCEL = 50216,
// // CFETS X-BOND报价推送 注销 请求应答同50191，50192

//-----------------------------------------------------------------------------------
// E_FID_QB_CFETS_DEAL_DAYLINE_QUERY			= 50217,
// // 查询CFETS成交日线 请求
struct xQBCFETSDealDaylineReq_t {
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_listed_market[8];
  char m_companyid[32 + 1];  //'50' = CFETS
  int m_beginDate;  // bengin,end 为-1 分别表示从最早 到 最新
  int m_endDate;
};
// 应答
typedef struct xQBCFETSDealDaylineUnit_t {
 public:
  float m_Yield;  // 价格
  int m_Symbol;   // 1:bid, -1: ask，成交日线可不用本字段
  UINT m_Date;    // 日期
} QBCFETSDealDaylineUnit;

struct xQBCFETSDealDaylineAck_t {
 public:
  char m_companyid[32 + 1];  //'50' = CFETS
  char m_bond_key[32 + 1];
  char m_listed_market[8];
  std::list<QBCFETSDealDaylineUnit> m_List;
};

// E_FID_QB_CFETS_MARKET_STREAM_DEAL_REQ			= 50264,
// //CFETS当日成交逐笔 请求应答同 E_FID_QB_MARKET_STREAM_DEAL_REQ 50124

// E_FID_QB_CSI_AUTHORITY_REQ	= 50265, //请求中证估值权限 请求
typedef xCDCAuthorityReq_c xCSIAuthorityReq_c;
// 应答
struct xCSIAuthorityAct_c {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  int m_Allowed;             // 估值权限，0=无权限，1=有权限
  xCSIAuthorityAct_c() { memset(this, 0, sizeof(xCSIAuthorityAct_c)); };
};

//-----------------------------------------------------------------------------------
// E_FID_QB_DEPOSIT_QUERY						= 50225,
// // 基准利率,存款 无请求包体，应答结构如下 活期	CMB1D00093 3M
// CMB1D00094 6M	CMB1D00095 1Y	CMB1D00096 2Y	CMB1D00097 3Y
// CMB1D00098 5Y	CMB1D00099

class xRateUnit_c {
 public:
  char m_code[16];  // Gjk_code
  double m_rate;    // 利率
  UINT m_date;
  xRateUnit_c() : m_rate(0), m_date(0) { memset(m_code, 0, sizeof(m_code)); }
};

class xDepositList_c {
 public:
  std::list<xRateUnit_c> m_List;  //,查询存款 list
};

//-----------------------------------------------------------------------------------
// E_FID_QB_LOAN_QUERY							= 50226,
// // 基准利率,贷款 无请求包体，应答结构如下 公积金（<=5Y）	CMB1M00410
// 公积金（>5Y）	CMB1M00411
//<6M	CMB1D00086
// 6M-1Y	CMB1D00087
// 1-3Y	CMB1D00088
// 3-5Y	CMB1D00089
// 5Y以上	CMB1D00090

class xLoanList_c {
 public:
  std::list<xRateUnit_c> m_List;  //,查询贷款 list
};

//-----------------------------------------------------------------------------------
// E_FID_QB_DEPOIST_LOAN_QUERY					= 50227,
// // 基准利率,存款及再贷款 无请求包体，应答结构如下 存准（大型机构）
// CMB1D00073 存准	CMB1D00072 法定存准利率	CMB1M00394 超额存准利率
// CMB1M00395 再贴现率	CMB1D00077 再贷款利率（<20D）	CMB1D00080
// 再贷款利率（<3M）	CMB1D00081
// 再贷款利率（<6M）	CMB1D00082
// 再贷款利率（1Y）	CMB1D00083

class xDepositLoanList_c {
 public:
  std::list<xRateUnit_c> m_List;  //,存款及再贷款 list
};

class xFinanceWeightingList_c {
 public:
  std::list<xRateUnit_c> m_List;  // 理财加权利率
};

class xWeightingLoanList_c {
 public:
  std::list<xRateUnit_c> m_List;  // 加权贷款利率
};

//-----------------------------------------------------------------------------------
// E_FID_QB_MM_CFETS_PRICE_QUERY_V2
// = 50229,		// 货币市场,查询CFETS实时行情

//-----------------------------------------------------------------------------------
// E_FID_QB_MM_EX_PRICE_QUERY_V2
// = 50230,			// 货币市场,查询交易所实时行情 请求应答同50229

//-----------------------------------------------------------------------------------
// E_FID_QB_MM_PRICE_PUSH_V3						= 50231,
// // 货币市场,注册推送实时行情 请求应答同50229

//-----------------------------------------------------------------------------------
// E_FID_QB_MM_PRICE_PUSH_CANCEL_V3				= 50232,
// // 货币市场,取消推送实时行情 请求同50229，无应答

// E_FID_QB_MARKET_STREAM_EX_REQ_V19 = 50236,查询Marketstream
// V19,高级查询，待筛选条件  V19

class xQBMarketStreamConditionReq_v19_c {
 public:
  int m_ReplyNum;  // 应答条数 如果不设或是-1， 返回所有的，默认为1
  std::set<std::string> m_CmpyList;  // 经纪公司列表数据

  std::set<std::string> m_BondSubtype;  // 产品

  std::set<std::string> m_IssuerCode;          // 发行人
  std::set<std::string> m_InstitutionSubtype;  // 类型
  std::set<std::string> m_BondRating;          // 主体
  std::set<std::string>
      m_IssuerRating;  // 债项					//
  std::set<std::string> m_BondIssuerCode;
  std::set<std::string> m_RateType;
  std::set<std::string> m_SectorCode;
  std::set<std::string> m_ProvinceCode;
  std::set<std::string> m_SpecialOption;

 public:
  std::set<uint64_t> m_Term;  // 期限
  std::string m_IsMunicipal;  // 城投
  std::string m_Guarantee;    // 担保
  std::string m_OptionType;   // 含权
  std::string m_Operate;

 public:
  xQBMarketStreamConditionReq_v19_c();
  xQBMarketStreamConditionReq_v19_c(QBMarketStreamConditionReq_t&);
  static uint32_t term2From(uint64_t);
  static uint32_t term2To(uint64_t);
  static uint64_t fromTo2Term(uint32_t, uint32_t);
  static std::string listJoin(std::set<std::string>&);
};

// E_FID_QB_GLOBAL_SWITCH						= 50250,
// //请求全局开关设置
typedef struct xQBGlobalSwitchReq_t {
  char m_Version[32 + 1];  // 版本信息，预留
  char m_UserID[32 + 1];   // 用户id
  xQBGlobalSwitchReq_t() {
    memset(m_Version, 0, sizeof(m_Version));
    memset(m_UserID, 0, sizeof(m_UserID));
  }
} QBGlobalSwitchReq_t, *PQBGlobalSwitchReq_t;

typedef struct xQBGlobalSwitchAck_t {
  char m_Version[32 + 1];                      // 版本信息，预留
  char m_UserID[32 + 1];                       // 用户id
  std::map<std::string, std::string> m_Flags;  // 全局开关Keys,Value
  xQBGlobalSwitchAck_t() {
    memset(m_Version, 0, sizeof(m_Version));
    memset(m_UserID, 0, sizeof(m_UserID));
  }
} QBGlobalSwitchAck_t, *PQBGlobalSwitchAck_t;

// 债券分时数据请求 E_FID_QB_BQ_REALTIME(50501)
typedef struct _tQBBondQuoteRealTimeReq {
  _tQBBondQuoteRealTimeReq() : begin_time(0), end_time(0) {
    memset(bond_key, 0, sizeof(bond_key));
    memset(company_id, 0, sizeof(company_id));
    memset(listed_mkt, 0, sizeof(listed_mkt));
  }

  char bond_key[33];   // 债券代码
  char company_id[3];  // 经纪商代码
  char listed_mkt[5];  // 债券市场
  time_t begin_time;  // 设置开始时间，如果不设，或者设置0，都代表当天的最早
  time_t end_time;  // 设置结束时间，如果不设，或者设置0，都代表当天的最晚,时间区间的数学表达式(beginTime,
                    // endTime]
} QBBondQuoteRealTimeReq, *pQBBondQuoteRealTimeReq;

// 债券分时数据应答
typedef struct _tQBBondQuoteRealTimeRsp {
  _tQBBondQuoteRealTimeRsp()
      : time(0),
        time_msec(0),
        open_price(0),
        high_price(0),
        low_price(0),
        close_price(0),
        pre_close(0),
        volume_total(0),
        amount_total(0) {
    memset(bond_key, 0, sizeof(bond_key));
    memset(company_id, 0, sizeof(company_id));
    memset(listed_mkt, 0, sizeof(listed_mkt));
  }

  char bond_key[33];    // 债券代码
  char company_id[3];   // 经纪商代码
  char listed_mkt[5];   // 债券市场
  time_t time;          // 成交时间
  int time_msec;        // 成交时的秒值，存在同一秒有多比交易
  float open_price;     // 开盘
  float high_price;     // 最高
  float low_price;      // 最低
  float close_price;    // 收盘
  float pre_close;      // 昨收价
  double volume_total;  // 总成交量
  double amount_total;  // 总成交额
} QBBondQuoteRealTimeRsp;

class xQBBondQuoteRealTimeList_c {
 public:
  std::list<_tQBBondQuoteRealTimeRsp> m_List;
};

// 债券历史数据请求
// 5分钟K线查询 E_FID_QB_BQ_HISQUOTE_5(50502)
// 日K线查询 E_FID_QB_BQ_HISQUOTE_DAY(50503)
// 周线查询 E_FID_QB_BQ_HISQUOTE_WEEK(50504)
// 月K线查询 E_FID_QB_BQ_HISQUOTE_MONTH(50505)
// 年K线查询 E_FID_QB_BQ_HISQUOTE_YEAR(50506)
typedef struct _tQBBondQuoteHisReq {
  _tQBBondQuoteHisReq() : begin_time(0), end_time(0), limit_count(0) {
    memset(bond_key, 0, sizeof(bond_key));
    memset(company_id, 0, sizeof(company_id));
    memset(listed_mkt, 0, sizeof(listed_mkt));
  }

  char bond_key[33];   // 债券代码
  char company_id[3];  // 经纪商代码
  char listed_mkt[5];  // 债券市场
  time_t begin_time;  // 设置开始时间，如果不设，或者设置0，都代表当天的最早
  time_t end_time;  // 设置结束时间，如果不设，或者设置0，都代表当天的最晚,时间区间的数学表达式(beginTime,
                    // endTime]
  int limit_count;  // 记录数量，代表离endTime最近的limit条记录，不设置或者设置-1，表示所有
} QBBondQuoteHisReq, *pQBBondQuoteHisReq;

// 债券历史5分钟数据应答
typedef struct _tQBBondQuoteHis5Rsp {
  _tQBBondQuoteHis5Rsp()
      : time(0),
        time_msec(0),
        open_price(0),
        high_price(0),
        low_price(0),
        close_price(0),
        volume(0),
        amount(0),
        volume_total(0),
        amount_total(0) {
    memset(bond_key, 0, sizeof(bond_key));
    memset(company_id, 0, sizeof(company_id));
    memset(listed_mkt, 0, sizeof(listed_mkt));
  }

  char bond_key[33];    // 债券代码
  char company_id[3];   // 经纪商代码
  char listed_mkt[5];   // 债券市场
  time_t time;          // 成交时间
  int time_msec;        // 成交时的秒值，存在同一秒有多比交易
  float open_price;     // 开盘
  float high_price;     // 最高
  float low_price;      // 最低
  float close_price;    // 收盘
  double volume;        // 成交量 手	每个K线周期内总的成交量
  double amount;        // 成交额 每个K线周期内总的成交额
  double volume_total;  // 总成交量
  double amount_total;  // 总成交额
} QBBondQuoteHis5Rsp;

class xQBBondQuoteHis5List_c {
 public:
  std::list<_tQBBondQuoteHis5Rsp> m_List;
};

// 债券历史数据应答
typedef struct _tQBBondQuoteHisRsp {
  _tQBBondQuoteHisRsp()
      : time(0),
        time_msec(0),
        open_price(0),
        high_price(0),
        low_price(0),
        close_price(0),
        volume(0),
        amount(0) {
    memset(bond_key, 0, sizeof(bond_key));
    memset(company_id, 0, sizeof(company_id));
    memset(listed_mkt, 0, sizeof(listed_mkt));
  }

  char bond_key[33];   // 债券代码
  char company_id[3];  // 经纪商代码
  char listed_mkt[5];  // 债券市场
  time_t time;         // 成交时间
  int time_msec;       // 成交时的秒值，存在同一秒有多比交易
  float open_price;    // 开盘
  float high_price;    // 最高
  float low_price;     // 最低
  float close_price;   // 收盘

  double volume;  // 成交量 手	每个K线周期内总的成交量
  double amount;  // 成交额 每个K线周期内总的成交额
} QBBondQuoteHisRsp;

class xQBBondQuoteHisList_c {
 public:
  std::list<_tQBBondQuoteHisRsp> m_List;
};

// E_FID_QB_EX_ALL_QUOTE_PUSH_V2					= 50601,
// //交易所报价行情流量优化版推送 无请求包体 应答同E_FID_QB_EX_BEST_QUOTE_PUSH

// E_FID_QB_EX_ALL_QUOTE_PUSH_V2_CANCEL			= 50602,
// //交易所报价行情流量优化版推送取消 无请求包体 无应答包体

//-------------------------------------------------------------------------------------
//--E_FID_QB_BOND_INFO_FINANCIAL_INDEX			= 50023,
//// 查询发行人的财务指标

// request
// E_FID_QB_BOND_INFO_FINANCIAL_INDEX
// 50023,查询发行人的财务指标
// xQBBondInfoFinancialIndexReq
class xQBBondInfoFinancialIndexReq_c {
 public:
  // IssuerCode
  char m_IssuerCode[16 + 1];  // 发行人代码
  // Count
  int m_Count;  // 要获取的财务指标条数，默认为6
  // FunctionBegin
  // 初始值
  xQBBondInfoFinancialIndexReq_c() {
    _InitializeString(m_IssuerCode);
    m_Count = 6;
  }
  // FunctionEnd
};

// inner
//
// 财务指标消息类
// xQBBondInfoFinancialIndexInfo
class xQBBondInfoFinancialIndexInfo_c {
 public:
  // Time
  time_t m_Time;  // 日期
  // EBITDA
  char m_EBITDA[10 + 1];  // EBITDA，单位：百万
  // CurrentRatio
  char m_CurrentRatio[10 + 1];  // 流动比率，单位：%
  // QuickRatio
  char m_QuickRatio[10 + 1];  // 速动比率，单位：%
  // InventoryVelocity
  char InventoryVelocity[10 + 1];  // 存货周转速度，单位：%
  // AccountReceivableVelocity
  char m_AccountReceivableVelocity[10 + 1];  // 应收账款周转速度，单位：%
  // TotalAssetsVelocity
  char m_TotalAssetsVelocity[10 + 1];  // 总资产周转速度，单位：%
  // RatioOfCashToIncome
  char m_RatioOfCashToIncome[10 + 1];  // 现金收入比，单位：%
  // GrossMargin
  char m_GrossMargin[10 + 1];  // 毛利率，单位：%
  // RatioOfTriCostToIncome
  char m_RatioOfTriCostToIncome[10 + 1];  // 三费收入比，单位：%
  // OperatingProfitRatio
  char m_OperatingProfitRatio[10 + 1];  // 营业利润率，单位：%
  // ReturnOnEquity
  char m_ReturnOnEquity[10 + 1];  // 净资产收益率，单位：%
  // EBITDAToOperatingIncome
  char m_EBITDAToOperatingIncome[10 + 1];  // EBITDA/营业收入，单位：%
  // DebtAssetRatio
  char DebtAssetRatio[10 + 1];  // 资产负债率，单位：%
  // AssetFixRatio
  char m_AssetFixRatio[10 + 1];  // 长期资本固定化比率，单位：%
  // OperatingNPVToCL
  char m_OperatingNPVToCL[10 + 1];  // 经营性净现金流/流动负债，单位：%
  // OperatingNPVToTL
  char m_OperatingNPVToTL[10 + 1];  // 经营性净现金流/总负债，单位：%
  // FunctionBegin
  // 初始值
  xQBBondInfoFinancialIndexInfo_c() {
    m_Time = 0;                            // 日期
    _InitializeString(m_EBITDA);           // EBITDA，单位：百万
    _InitializeString(m_CurrentRatio);     // 流动比率，单位：%
    _InitializeString(m_QuickRatio);       // 速动比率，单位：%
    _InitializeString(InventoryVelocity);  // 存货周转速度，单位：%
    _InitializeString(m_AccountReceivableVelocity);  // 应收账款周转速度，单位：%
    _InitializeString(m_TotalAssetsVelocity);  // 总资产周转速度，单位：%
    _InitializeString(m_RatioOfCashToIncome);  // 现金收入比，单位：%
    _InitializeString(m_GrossMargin);          // 毛利率，单位：%
    _InitializeString(m_RatioOfTriCostToIncome);  // 三费收入比，单位：%
    _InitializeString(m_OperatingProfitRatio);  // 营业利润率，单位：%
    _InitializeString(m_ReturnOnEquity);  // 净资产收益率，单位：%
    _InitializeString(m_EBITDAToOperatingIncome);  // EBITDA/营业收入，单位：%
    _InitializeString(DebtAssetRatio);  // 资产负债率，单位：%
    _InitializeString(m_AssetFixRatio);  // 长期资本固定化比率，单位：%
    _InitializeString(m_OperatingNPVToCL);  // 经营性净现金流/流动负债，单位：%
    _InitializeString(m_OperatingNPVToTL);  // 经营性净现金流/总负债，单位：%
  }
  const bool operator<(const xQBBondInfoFinancialIndexInfo_c& obj) const {
    return (m_Time > obj.m_Time);
  }
  // FunctionEnd
};

// response
// E_FID_QB_BOND_INFO_FINANCIAL_INDEX
// 50023,查询发行人的财务指标
// xQBBondInfoFinancialIndexAck
class xQBBondInfoFinancialIndexAck_c {
 public:
  xQBBondInfoFinancialIndexAck_c() { _InitializeString(m_IssuerCode); }
  // IssuerCode
  char m_IssuerCode[16 + 1];  // 发行人代码
  // List
  std::list<xQBBondInfoFinancialIndexInfo_c> m_List;  // 财务指标列表
};

//-------------------------------------------------------------------------------------
// E_FID_QB_USERPERM_APPLY = 50281,			//功能权限申请
// E_FID_QB_USERPERM_APPLY_QUERY = 50282,
// //功能权限申请状态查询 request
struct xQBUserPermApplyReq_t {
  char m_userId[32 + 1];  // QB用户id
  char m_functionCode[64];  // 功能code，该字段为空，则返回该用户所有申请过的
                            // permission权限
  char m_permValue[16];  // 申请的权限值
  xQBUserPermApplyReq_t() { memset(this, 0, sizeof(xQBUserPermApplyReq_t)); };
};

// response
struct xQBUserpermApplyData {
  char m_functionCode[64];  // 功能code
  char m_permValue[16];     // 申请的权限值
  int m_applyStatus;  // 审核状态(1-申请中;2-审核通过;3-审核拒绝)
  time_t m_createTime;
  time_t m_modifyTime;
  char m_modifyBy[64];
  xQBUserpermApplyData() { memset(this, 0, sizeof(xQBUserpermApplyData)); }
};
struct xQBUserPermApplyAck_t {
 public:
  std::list<xQBUserpermApplyData> m_data;  // 申请过的权限列表
};

// E_FID_QB_USER_MEMBER_INFO_REQ = 50283，
// //QB会员信息及BP查询 请求 xUserMemberInfoReq_c
class xUserMemberInfoReq_c {
 public:
  // UserID
  char m_UserId[33];  // 用户ID
  // UserAccount
  char m_UserAccount[64];  // QB用户名（QM登录名）

  char m_CompanyId[32 + 1];  // 所属机构id

  xUserMemberInfoReq_c() {
    _InitializeString(m_UserId);
    _InitializeString(m_UserAccount);
    _InitializeString(m_CompanyId);
  }
};
// 应答
// xUserMemberInfoAck_c
struct sUserMemberLevelList {
  int m_Level;  // 等级
  int m_MinBp;  // Bp
  sUserMemberLevelList() {
    m_Level = 0;
    m_MinBp = 0;
  }
};
class xUserMemberInfoAck_c {
 public:
  char m_UserId[33];         // 用户ID
  char m_UserAccount[64];    // QB用户名（QM登录名）
  char m_CompanyId[32 + 1];  // 所属机构id
  char m_MemberLevel[2];     // 1-5级， 会员另外表示
  char m_IsPaidCustom[2];  // 是否付费用户， “1"表示付费，“0”或""表示普通用户
  int m_CurrentMonthBp;  // 当期Bp, 登录Bp + 打开页面Bp, 各有阈值
  int m_TotalBp;         // 累积Bp
  int m_OpenPageBpCanGetToday;  // 通过打开页面还能获取多少Bp,需要后台判断是否达到阈值
  char m_FirstLogInReceived[2];  // “1”表示能发送第一次登录的请求，
                                 // “0”或“”表示没有收到
  char m_FirstOpenRecommendReceived
      [2];  //"1"表示能发送第一次打开页面的请求，“0”或“”表示没有收到
  std::list<sUserMemberLevelList> m_ListLevel;  // 会员level对应Bp 值，可配

  xUserMemberInfoAck_c() {
    _InitializeString(m_UserId);
    _InitializeString(m_UserAccount);
    _InitializeString(m_CompanyId);
    _InitializeString(m_MemberLevel);
    _InitializeString(m_IsPaidCustom);
    m_CurrentMonthBp = 0;
    m_TotalBp = 0;
    m_OpenPageBpCanGetToday = 0;
    _InitializeString(m_FirstLogInReceived);
    _InitializeString(m_FirstOpenRecommendReceived);
  }
};
// E_FID_QB_USER_MEMBER_INFO_PUSH = 50284，
// //QB会员等级或BP变化推送，针对单个用户 请求同//xUserMemberInfoReq_c
typedef xUserMemberInfoReq_c xUserMemberInfoPush_c;
// 应答同xUserMemberInfoAck_c
// E_FID_QB_USER_MEMBER_INFO_PUSH_CANCEL = 50285，
// //QB会员等级或BP变化取消推送，针对单个用户 请求同//xUserMemberInfoReq_c
typedef xUserMemberInfoReq_c xUserMemberInfoPushCancel_c;
// 无应答

// E_FID_QB_USER_MEMBER_BP_CHANGE_REQ = 50286，
// //客户登录或者打开页面发送，需要判断是不是第一次登录或者第一次打开 请求
// xUserMemberBpChange_c
class xUserMemberBpChange_c {
 public:
  // UserID
  char m_UserId[33];  // 用户ID
  // UserAccount
  char m_UserAccount[64];    // QB用户名（QM登录名）
  char m_CompanyId[32 + 1];  // 所属机构id

  char m_Login[2];  // "1"表示登录, "0"或“”表示非登录
  char m_OpenRecommendPage[2];  // "1"表示打开页面，“0”或“”表示没有打开页面

  xUserMemberBpChange_c() {
    _InitializeString(m_UserId);
    _InitializeString(m_UserAccount);
    _InitializeString(m_CompanyId);
    _InitializeString(m_Login);
    _InitializeString(m_OpenRecommendPage);
  }
};
// 应答同xUserMemberInfoAck_c
typedef xUserMemberInfoAck_c xUserMemberBpChangeAck_c;

//-------------------------------------------------------------------------------------
//--E_FID_QB_FINACIAL_DATA						= 50300,
////债券详情页--查询发行人的财务数据

// request
// E_FID_QB_FINACIAL_DATA
// 50300,债券详情页--查询发行人的财务数据,请求字段与50023相同
// xQBFinacialDataReq
typedef xQBBondInfoFinancialIndexReq_c xQBFinacialDataReq_c;

// response
// E_FID_QB_FINACIAL_DATA
// 50300,债券详情页--查询发行人的财务数据
// xQBFinacialDataAck
class xQBFinacialDataAck_c {
 public:
  xQBFinacialDataAck_c() { _InitializeString(m_IssuerCode); }
  // IssuerCode
  char m_IssuerCode[16 + 1];  // 发行人代码
  // FinacialDataMapList
  std::list<std::map<std::string, std::string>>
      m_FinacialDataMapList;  // 财务数据List，项数为请求中指定的数值；每一项为财务数据的map，key为数据项ID，value为数据项的值；一个特殊项，key为“Date”，value为“20140601”形式的数据日期。后台以message形式传输，前台会循环获取所有字段（Date字段由后台保证）。
};

// E_FID_QB_BESTPRICE_SYNTHETICAL_REQ = 50290,
// //债券详情-最优报价（5家综合）请求 请求
struct xQBBestPriceSyntheticalReq_c {
  char m_UserId[32 + 1];  // 用户id
  char m_BondKey[32 + 1];
  char m_ListedMarket[8];

  xQBBestPriceSyntheticalReq_c() {
    memset(this, 0, sizeof(xQBBestPriceSyntheticalReq_c));
  };
};
// 应答
struct xQBBestPriceSynthetical_Unit_c {
  char m_id[32 + 1];  // id
  char m_price[12];   // 收益率',
  char m_quotetype[4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差

  char m_clean_price[12];  // 净价
  char m_full_price[12];   // 全价
  char m_yield[12];        // 收益率
  char m_volume[64];       // 数量，总价',
  char m_bp_status[8];  // m_deal_status, 与成交区分，故改为m_bp_status,
                        // 订单状态 \n-1：待审核 \n0：发布\n1：成交\n2：作废',
  xQBBestPriceSynthetical_Unit_c() {
    memset(this, 0, sizeof(xQBBestPriceSynthetical_Unit_c));
  }
};
struct xQBBestPriceSyntheticalAck_c {
  char m_bondkey[32 + 1];  // 产品ID',== bondkey
  char m_listedmarket[8];  // 市场代码
  time_t m_time;           // datetime DEFAULT NULL,
  int m_version;  // 版本索引，每个公司唯一自增，从0开始
  xQBBestPriceSynthetical_Unit_c m_bid;
  xQBBestPriceSynthetical_Unit_c m_ofr;

  xQBBestPriceSyntheticalAck_c() : m_time(0), m_version(0) {
    _InitializeString(m_bondkey);
    _InitializeString(m_listedmarket);
  };
};
// E_FID_QB_BESTPRICE_SYNTHETICAL_PUSH = 50291,
// //债券详情-最优报价（5家综合）注册推送 请求应答同50290
// E_FID_QB_BESTPRICE_SYNTHETICAL_PUSH_CANCEL = 50292,
// 请求同50290，无应答

//-------------------------------------------------------------------------------------
//--E_FID_QB_BOND_CAL							= 50189,
////债券计算器，预留
/*
//inner
//
//cashflow结构
//CashflowStruct
class CashflowStruct_c
{
public:
        //adjustedDate
        std::string m_adjustedDate;//'20180718',
        //date
        std::string m_date;//'20180718',
        //coupon
        double m_coupon;//6.600000000000006,
        //couponRate
        double m_couponRate;//0.066,
        //redemption
        double m_redemption;//0.0,
        //startPrincipal
        double m_startPrincipal;//100.0
        //FunctionBegin
        //初始值
        CashflowStruct_c()
        {
                m_adjustedDate = "";
                m_date = "";
                m_coupon = 0.0f;
                m_couponRate = 0.0f;
                m_redemption = 0.0f;
                m_startPrincipal = 0.0f;
        }
        //FunctionEnd
};
*/
// 计算条件中，有五个关联字段作为条件发送
// 可以不发送
// 最多只能发送其中之一，其它四项会用计算结果返回
// 不发送的字段不能以0值发送
// 此枚举用于包装消息时判断要发送哪一个字段
enum CalculateInputIndicator {
  NOINPUT = 0,     // 不发送
  CLEANPRICE = 1,  // 净价
  FULLPRICE = 2,   // 全价
  YIELD = 3,       // 收益率
  SPREAD =
      4,  // 利差。只对浮动券有效。由字段m_indexDate（参考利率日期）是否为空判断。
  YIELDTOEXECUTION =
      5  // 行权收益率。由字段m_executionDate（行权日期）是否为空判断。
};

// 现金流
class CashflowStruct_c {
 public:
  std::string m_date;   // 日期
  double m_coupon;      // 利息支付
  double m_redemption;  // 本金支付
  double m_amount;      // 现金流总和

  CashflowStruct_c() {
    m_date = "";
    m_coupon = INVALID_VALUE_CAL;
    m_redemption = INVALID_VALUE_CAL;
    m_amount = INVALID_VALUE_CAL;
  }

  bool operator==(const CashflowStruct_c& c) const {
    return (m_date == c.m_date && Equal(m_coupon, c.m_coupon) &&
            Equal(m_redemption, c.m_redemption));
  }
  bool operator!=(const CashflowStruct_c& c) const {
    return (m_date != c.m_date || !Equal(m_coupon, c.m_coupon) ||
            !Equal(m_redemption, c.m_redemption));
  }

 private:
  bool Equal(double a, double b) const {
    const double kEps = 0.000001;
    return fabs(a - b) < kEps;
  }
};

// inner
//
// 债券价格计算结构
// BondMessage
class BondMessage_c {
 public:
  // 发送必有字段：
  // bondKey
  std::string m_bondKey;  // 债券主键
  // listedMarket
  std::string
      m_listedMarket;  // CIB by default, could be CIB, SSE, SZE 交易市场
  // notional
  double m_notional;  // 名义本金-券面总额
  // settlementDate
  std::string m_settlementDate;  // 结算日期, 如 20140303
  // couponrateCurrent
  double m_couponrateCurrent;  // 票面利率

  // 发送限制字段：以下五个字段中，不发送不触发这些字段的互算，或者只选其一发送计算其它四项
  // 指示器，不参与消息包装
  CalculateInputIndicator m_Indicator;  // 指示器
  // cleanPrice
  double m_cleanPrice;  // 净价
  // fullPrice
  double m_fullPrice;  // 全价
  // yield
  double m_yield;  // 收益率
  // spread
  double
      m_spread;  // 利差。只对浮动券有效。由字段m_indexDate（参考利率日期）是否为空判断。
  // yieldToExecution
  double
      m_yieldToExecution;  // 行权收益率。由字段m_executionDate（行权日期）是否为空判断。

  // parRFRates
  std::string m_parRFRates;  // 到期 G-Spread
  // spotRFRates
  std::string m_spotRFRates;  // 即期 Z-Spread
  // returnCashflow
  bool m_returnCashflow;  // 是否返回现金流
  // customCashflow
  std::vector<CashflowStruct_c> m_customCashflow;  // 自定义现金流

  // 可发送作为计算条件，也可不发送作为结果接收字段：
  // predictRate
  double
      m_predictRate;  // 预测利率-基准利率,可自定义作为输入。只对浮动券有效。由字段m_indexDate（参考利率日期）是否为空判断。

  // 接收字段：
  // indexDate
  std::string
      m_indexDate;  // 参考利率日期-利率日期。根据本字段是否为空判断是否为浮动券。
  // settlementAmount
  double m_settlementAmount;  // 结算金额
  // macaulayDuration
  double m_macaulayDuration;  // 麦氏久期
  // modifiedDuration
  double m_modifiedDuration;  // 修正久期
  // pvbp
  double m_pvbp;  // 基点价值-PVBP
  // convexity
  double m_convexity;  // 凸性
  // accruedDays
  int m_accruedDays;  // 应计利息天数-计息天数
  // accruedAmount
  double m_accruedAmount;  // 应计利息
  // maturityDate
  std::string m_maturityDate;  // 到期日-兑付日
  // executionDate
  std::string
      m_executionDate;  // 行权日期--根据此字段是否为空判断是否含权。输入&输出
  // roundCleanPrice
  bool m_roundCleanPrice;  // 是否保留净价4位，true为4位，false为6位

  // accrualDayCounter
  std::string m_accrualDayCounter;  // 计息基准
  // zSpread
  double m_zSpread;  // Z-Spread
  // gSpread
  double m_gSpread;  // G-Spread
  // cashflow
  std::vector<CashflowStruct_c> m_cashflow;  // 现金流列表
  bool m_bIsSendCouponRate;

  // 不使用的字段
  /*
  //tradeDate
  std::string m_tradeDate;                    // 交易日期, 如 20140303
  //tenor
  std::string m_tenor;                        // 可以是 1D, 2W, 3M
  //convention
  std::string m_convention;//could be "ModifiedFollowing", "Following",
  "Preceding", "Unadjusted"
  //rebate
  double m_rebate;                       //返点, 单位元
  //yieldToCall
  double m_yieldToCall;                  //Call收益率
  //callDate
  std::string m_callDate;                     //Call日期
  //yieldToPut
  double m_yieldToPut;                   //Put收益率
  //putDate
  std::string m_putDate;                      //Put日期
  //returnCashflow
  bool m_returnCashflow;      //是否返回现金流
  //cashflow
  std::list<std::map<std::string, CashflowStruct_c>> m_cashflow;  //现金流列表
  */
  // FunctionBegin
  // 初始值
  BondMessage_c() {
    m_bondKey = "";
    m_listedMarket = "CIB";
    m_maturityDate = "";
    m_notional = INVALID_VALUE_CAL;
    m_settlementAmount = INVALID_VALUE_CAL;
    m_Indicator = NOINPUT;
    // m_tradeDate = "";
    // m_tenor = "";
    // m_convention = "ModifiedFollowing";
    m_settlementDate = "";
    m_yield = INVALID_VALUE_CAL;
    m_cleanPrice = INVALID_VALUE_CAL;
    m_fullPrice = INVALID_VALUE_CAL;
    m_accruedAmount = INVALID_VALUE_CAL;
    m_accruedDays = 0;
    // m_rebate = 0.0f;
    // m_yieldToCall = 0.0f;
    // m_callDate = "";
    // m_yieldToPut = 0.0f;
    // m_putDate = "";
    m_yieldToExecution = INVALID_VALUE_CAL;
    m_executionDate = "";
    m_predictRate = INVALID_VALUE_CAL;
    m_indexDate = "";
    m_spread = INVALID_VALUE_CAL;
    m_macaulayDuration = INVALID_VALUE_CAL;
    m_modifiedDuration = INVALID_VALUE_CAL;
    m_pvbp = INVALID_VALUE_CAL;
    m_convexity = INVALID_VALUE_CAL;
    m_roundCleanPrice = true;
    // m_returnCashflow = false;
    // m_roundCleanPrice = true;

    m_parRFRates = "";
    m_spotRFRates = "";
    m_returnCashflow = false;
    m_accrualDayCounter = "";
    m_zSpread = INVALID_VALUE_CAL;
    m_gSpread = INVALID_VALUE_CAL;
    m_cashflow.clear();
    m_customCashflow.clear();
    m_bIsSendCouponRate = true;
  }
  // FunctionEnd
};

// request
// E_FID_QB_BOND_CAL
// 50189,债券计算器
// xQBBondCalReq
class xQBBondCalReq_c {
 public:
  // List
  std::list<BondMessage_c>
      m_List;  // 计算发送请求列表与返回结果列表（发送与返回使用同一结构）
};

// response
// E_FID_QB_BOND_CAL
// 50189,债券计算器
// xQBBondCalAck
typedef xQBBondCalReq_c xQBBondCalAck_c;

//-------------------------------------------------------------------------------------
// E_FID_QB_BOND_CAL_SPECIFIC_ITEMS_REQ = 50332,
// //债券计算器，请求含权债特殊条款 请求 class xBondKey_c

// 应答
class xQBBondCalSpecificItemsAck_c : public xBondKey_c {
 public:
  std::list<std::string> m_ItemType;  // 特殊条款类型
  std::string m_Content;              // 条款内容

  xQBBondCalSpecificItemsAck_c(){};
};

/**************************************
        账户的升级权限，QBFLAG等实时数据库数据更新推送接收
************************************************/
//--E_FID_QB_ACCOUNT_UPDATEINFO_PUSH				= 57500,
////服务器推送升级权限等

// inner
//
//
// xQBAccountUpdateInfoAck
class xQBAccountUpdateInfoAck_c {
 public:
  // ID
  char m_ID[32 + 1];
  // USERNAME
  char m_UserName[64];
  // AUTO_UPDATE_FLAG
  char m_UpdateRight[4];  // 升级权限
  // QB_FLAG
  char m_QBFlag[4];
  // FunctionBegin
  // 初始值
  xQBAccountUpdateInfoAck_c() {
    _InitializeString(m_ID);
    _InitializeString(m_UserName);
    _InitializeString(m_UpdateRight);
    _InitializeString(m_QBFlag);
  }
  // FunctionEnd
};
// response
// E_FID_QB_ACCOUNT_UPDATEINFO_PUSH
// 57500,服务器推送升级权限等
// xQBAccountUpdateInfoPush
class xQBAccountUpdateInfoPush_c {
 public:
  // type
  char m_type[10];  // 操作类型
  // new
  xQBAccountUpdateInfoAck_c m_newInfo;  // 新信息
  // old
  xQBAccountUpdateInfoAck_c m_oldInfo;  // 旧信息
  // FunctionBegin
  // 初始值
  xQBAccountUpdateInfoPush_c() { _InitializeString(m_type); }
  // FunctionEnd
};

////////////////////////////////////////////////////////////////////////////////////////////////////////
// 平安证券
class xMarketIndexBaseReq_c  // 基类:数据识别标识
{
 public:
  // UserID
  char m_UserID[32 + 1];  // 当前用户ID
  // CompanyID
  char m_CompanyId[32 + 1];  // 所属机构id
  // FunctionBegin
  // 初始值
  xMarketIndexBaseReq_c() {
    _InitializeString(m_UserID);
    _InitializeString(m_CompanyId);
  }
  // FunctionEnd
};

// Req  请求
//--E_FID_PA_MARKET_INDEX_THERMOMETER_REQ			= 58001,
////平安，请求，债市温度计
//--E_FID_PA_MARKET_INDEX_LEADING_REQ				= 58002,
////平安，请求，金融市场综合经济领先指数
//--E_FID_PA_MARKET_INDEX_COMPOSITE_REQ			= 58003,
////平安，请求，货币市场综合指数
//--E_FID_PA_MARKET_INDEX_SUBSCRIBE_REQ			= 58004,
////平安，请求，一级市场认购情绪指数
//--E_FID_GKH_INDEX_GKZ_REQ
//= 58029,			//国开行，请求，应答，国开指数
//--前台、后台都需要 request
// E_FID_PA_MARKET_INDEX_THERMOMETER_REQ,E_FID_PA_MARKET_INDEX_LEADING_REQ,E_FID_PA_MARKET_INDEX_COMPOSITE_REQ,E_FID_PA_MARKET_INDEX_SUBSCRIBE_REQ
// E_FID_PA_MARKET_INDEX_THERMOMETER_REQ	=
// 58001,平安，请求，债市温度计;E_FID_PA_MARKET_INDEX_LEADING_REQ	=
// 58002,平安，请求，金融市场综合经济领先指数;E_FID_PA_MARKET_INDEX_COMPOSITE_REQ
// = 58003,平安，请求，货币市场综合指数;E_FID_PA_MARKET_INDEX_SUBSCRIBE_REQ
// = 58004,平安，请求，一级市场认购情绪指数 xMarketIndexReq
class xMarketIndexReq_c : public xMarketIndexBaseReq_c {
 public:
  // Count
  int m_Count;  //-1表示全部
  // Time
  time_t
      m_Time;  // 日期，截止时间。m_Count为-1时，不需要设置，否则需要设置具体时间，即某时间前m_Count期数据。
  // FunctionBegin
  // 初始值
  xMarketIndexReq_c() {
    m_Count = -1;
    m_Time = 0;
  }
  // FunctionEnd
};

//--E_FID_PA_MARKET_INDEX_DESCRIPTION_REQ			= 58013,
////平安，请求, 指标说明
//--E_FID_PA_MARKET_INDEX_DESCRIPTION_SUBMIT		= 58015,
////平安，提交, 指标说明 request
// E_FID_PA_MARKET_INDEX_DESCRIPTION_REQ,E_FID_PA_MARKET_INDEX_DESCRIPTION_SUBMIT
// 58013,平安，请求, 指标说明;58015,平安，提交, 指标说明
// xMarketIndexDescriptionReq
class xMarketIndexDescriptionReq_c : public xMarketIndexBaseReq_c {
 public:
  // Type
  int m_Type;  // 0 温度计  1 金融市场综合领先指标 2 货币市场综合指数 3
               // 一级市场认购情绪指数 4.国开指数
  // Description
  char m_Description[256];  // 指标说明,请求时此字段不用赋值
  // FunctionBegin
  // 初始值
  xMarketIndexDescriptionReq_c() {
    m_Type = 0;
    _InitializeString(m_Description);
  }
  // FunctionEnd
};

//--58015返回值为空，从返回消息头中获取是否成功

//--E_FID_PA_MARKET_INDEX_DESCRIPTION_REQ			= 58013,
////平安，应答, 指标说明
//--E_FID_PA_MARKET_INDEX_DESCRIPTION_PUSH		= 58014,
////平安，推送，指标说明

// response
// E_FID_PA_MARKET_INDEX_DESCRIPTION_REQ,E_FID_PA_MARKET_INDEX_DESCRIPTION_PUSH
// 58013,平安，应答, 指标说明;58014,平安，推送，指标说明
// xMarketIndexDescriptionAck
typedef xMarketIndexDescriptionReq_c xMarketIndexDescriptionAck_c;

// inner
//
// 债券温度计
// xMarketThermometer
class xMarketThermometer {
 public:
  // Flag
  BYTE m_Flag;  // 标识，0表示修改，1表示增加，2表示删除,此字段针对对向服务器发送
  // Time
  time_t m_Time;  // 日期
  // ArbSpread
  char m_ArbSpread[12];  // 套利利差
  // FundingRate
  char m_FundingRate[12];  // 资金利率
  // TaxSpread
  char m_TaxSpread[12];  // 税收利差
  // CreditSpread
  char m_CreditSpread[12];  // 信用利差
  // RatingSpread
  char m_RatingSpread[12];  // 评级利差
  // TermSpread
  char m_TermSpread[12];  // 期限利差
  // FunctionBegin
  // 初始值
  xMarketThermometer() {
    m_Flag = 0;
    m_Time = 0;
    _InitializeString(m_ArbSpread);
    _InitializeString(m_FundingRate);
    _InitializeString(m_TaxSpread);
    _InitializeString(m_CreditSpread);
    _InitializeString(m_RatingSpread);
    _InitializeString(m_TermSpread);
  }
  // FunctionEnd

  bool operator<(const xMarketThermometer& obj) const {
    return this->m_Time < obj.m_Time;
  }
};

//--E_FID_PA_MARKET_INDEX_THERMOMETER_SUBMIT		= 58009,
////平安，提交，债市温度计

// request
// E_FID_PA_MARKET_INDEX_THERMOMETER_SUBMIT
// 58009,平安，提交，债市温度计
// xMarketThermometerListReq
class xMarketThermometerListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xMarketThermometer> m_List;  // 债券温度计列表
};

//--E_FID_PA_MARKET_INDEX_THERMOMETER_REQ			= 58001,
////平安，应答，债市温度计
//--E_FID_PA_MARKET_INDEX_THERMOMETER_PUSH		= 58005,
////平安，推送，债市温度计

// response
// E_FID_PA_MARKET_INDEX_THERMOMETER_REQ,E_FID_PA_MARKET_INDEX_THERMOMETER_PUSH
// 58001,平安，应答，债市温度计;58005,平安，推送，债市温度计
// xMarketThermometerListAck
typedef xMarketThermometerListReq_c xMarketThermometerListAck_c;

// inner
//
// 金融市场综合经济领先指数
// xMarketLeadingIndex
class xMarketLeadingIndex {
 public:
  // Flag
  BYTE m_Flag;  // 标识，0表示修改，1表示增加，2表示删除
  // Time
  time_t m_Time;  // 日期
  // LeadingIndex
  char m_LeadingIndex[12];  // 领先指数
  // WarningLine
  char m_WarningLine[12];  // 预警线
  // EAMonetary
  char m_EAMonetary[12];  // 东亚货币
  // BrentCrudeOil
  char m_BrentCrudeOil[12];  // 布化特原油
  // CopperFuture
  char m_CopperFuture[12];  // 国内铜期货
  // 10YNationalDebt
  char m_10YNationalDebt[12];  // 10Y国债
  // HSCEI
  char m_HSCEI[12];  // 恒生国企指数
  // FunctionBegin
  // 初始值
  xMarketLeadingIndex() {
    m_Flag = 0;
    m_Time = 0;
    _InitializeString(m_LeadingIndex);
    _InitializeString(m_WarningLine);
    _InitializeString(m_EAMonetary);
    _InitializeString(m_BrentCrudeOil);
    _InitializeString(m_CopperFuture);
    _InitializeString(m_10YNationalDebt);
    _InitializeString(m_HSCEI);
  }
  bool operator<(const xMarketLeadingIndex& obj) const {
    return this->m_Time < obj.m_Time;
  }
  // FunctionEnd
};

//--E_FID_PA_MARKET_INDEX_LEADING_SUBMIT			= 58010,
////平安，提交，金融市场综合经济领先指数

// request
// E_FID_PA_MARKET_INDEX_LEADING_SUBMIT
// 58010,平安，提交，金融市场综合经济领先指数
// xMarketLeadingIndexListReq
class xMarketLeadingIndexListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xMarketLeadingIndex> m_List;
};

//--E_FID_PA_MARKET_INDEX_LEADING_REQ				= 58002,
////平安，应答，金融市场综合经济领先指数
//--E_FID_PA_MARKET_INDEX_LEADING_PUSH			= 58006,
////平安，推送，金融市场综合经济领先指数
//--E_FID_PA_MARKET_INDEX_LEADING_REQ				= 58002,
////平安，应答，金融市场综合经济领先指数
//--E_FID_PA_MARKET_INDEX_LEADING_PUSH			= 58006,
////平安，推送，金融市场综合经济领先指数

// response
// E_FID_PA_MARKET_INDEX_LEADING_REQ,E_FID_PA_MARKET_INDEX_LEADING_PUSH,E_FID_PA_MARKET_INDEX_LEADING_REQ,E_FID_PA_MARKET_INDEX_LEADING_PUSH
// 58002,平安，应答，金融市场综合经济领先指数;58006,平安，推送，金融市场综合经济领先指数;58002,平安，应答，金融市场综合经济领先指数;58006,平安，推送，金融市场综合经济领先指数
// xMarketLeadingIndexListAck
typedef xMarketLeadingIndexListReq_c xMarketLeadingIndexListAck_c;

// inner
//
// 金融市场综合经济领先指数
// xMarketCompositeIndex
class xMarketCompositeIndex {
 public:
  // Flag
  BYTE m_Flag;  // 标识，0表示修改，1表示增加，2表示删除
  // Time
  time_t m_Time;  // 日期
  // WeightedDeadLine
  char m_WeightedDeadLine[12];  // 加权成交期限
  // InterbankRepo
  char m_InterbankRepo[12];  // 拆借回购
  // FinanceingScale
  char m_FinanceingScale[12];  // 融资规模
  // 3Mshibor
  char m_3Mshibor[12];  // 3Mshibor
  // CompositeIndex
  char m_CompositeIndex[12];  // 综合指标
  // R007
  char m_R007[12];  // R007:右轴
  // CriticalValue
  char m_CriticalValue[12];  // 临界值
  // FunctionBegin
  // 初始值
  xMarketCompositeIndex() {
    m_Flag = 0;
    m_Time = 0;
    _InitializeString(m_WeightedDeadLine);
    _InitializeString(m_InterbankRepo);
    _InitializeString(m_FinanceingScale);
    _InitializeString(m_3Mshibor);
    _InitializeString(m_CompositeIndex);
    _InitializeString(m_R007);
    _InitializeString(m_CriticalValue);
  }
  bool operator<(const xMarketCompositeIndex& obj) const {
    return this->m_Time < obj.m_Time;
  }
  // FunctionEnd
};

//--E_FID_PA_MARKET_INDEX_COMPOSITE_SUBMIT		= 58011,
////平安，提交，货币市场综合指数

// request
// E_FID_PA_MARKET_INDEX_COMPOSITE_SUBMIT
// 58011,平安，提交，货币市场综合指数
// xMarketCompositeIndexListReq
class xMarketCompositeIndexListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xMarketCompositeIndex> m_List;
};

//--E_FID_PA_MARKET_INDEX_COMPOSITE_REQ			= 58003,
////平安，应答，货币市场综合指数
//--E_FID_PA_MARKET_INDEX_COMPOSITE_PUSH			= 58007,
////平安，推送，货币市场综合指数

// response
// E_FID_PA_MARKET_INDEX_COMPOSITE_REQ,E_FID_PA_MARKET_INDEX_COMPOSITE_PUSH
// 58003,平安，应答，货币市场综合指数;58007,平安，推送，货币市场综合指数
// xMarketCompositeIndexListAck
typedef xMarketCompositeIndexListReq_c xMarketCompositeIndexListAck_c;

// inner
//
// 市场认购情系指数
// xMarketSubSenIndex
class xMarketSubSenIndex {
 public:
  // Index
  char m_Index[12];  // 情系指数
  // 3MA
  char m_3MA[12];  // 3期MA
  // HistoryAverage
  char m_HistoryAverage[12];  // 历史均值
  // FunctionBegin
  // 初始值
  xMarketSubSenIndex() {
    _InitializeString(m_Index);
    _InitializeString(m_3MA);
    _InitializeString(m_HistoryAverage);
  }
  // FunctionEnd
};

// inner
//
// 一级市场认购情绪指数
// xPriMarSubSenIndex
class xPriMarSubSenIndex {
 public:
  // Flag
  BYTE m_Flag;  // 标识，0表示修改，1表示增加，2表示删除
  // Time
  time_t m_Time;  // 日期
  // RS
  xMarketSubSenIndex m_RS;  // 利率债
  // HGCD
  xMarketSubSenIndex m_HGCD;  // 高等级信用债
  // LMGCD
  xMarketSubSenIndex m_LMGCD;  // 中低等级信用债
  // FunctionBegin
  // 初始值
  xPriMarSubSenIndex() {
    m_Flag = 0;
    m_Time = 0;
  }
  bool operator<(const xPriMarSubSenIndex& obj) const {
    return this->m_Time < obj.m_Time;
  }
  // FunctionEnd
};

//--E_FID_PA_MARKET_INDEX_SUBSCRIBE_SUBMIT		= 58012,
////平安，提交，一级市场认购情绪指数

// request
// E_FID_PA_MARKET_INDEX_SUBSCRIBE_SUBMIT
// 58012,平安，提交，一级市场认购情绪指数
// xPriMarSubSenIndexListReq_c
class xPriMarSubSenIndexListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xPriMarSubSenIndex> m_List;
};

//--E_FID_PA_MARKET_INDEX_SUBSCRIBE_REQ			= 58004,
////平安，应答，一级市场认购情绪指数
//--E_FID_PA_MARKET_INDEX_SUBSCRIBE_PUSH			= 58008,
////平安，推送，一级市场认购情绪指数

// response
// E_FID_PA_MARKET_INDEX_SUBSCRIBE_REQ,E_FID_PA_MARKET_INDEX_SUBSCRIBE_PUSH
// 58004,平安，应答，一级市场认购情绪指数;58008,平安，推送，一级市场认购情绪指数
// xPriMarSubSenIndexListAck
typedef xPriMarSubSenIndexListReq_c xPriMarSubSenIndexListAck_c;

//--E_FID_PA_MARKET_INDEX_REGISTER					= 58020,
////平安，向网关注册实时更新信息 request E_FID_PA_MARKET_INDEX_REGISTER
// 58020,平安，向网关注册实时更新信息
// xMarketIndexRegisterReq
typedef xMarketIndexBaseReq_c xMarketIndexRegisterReq_c;

//--E_FID_PA_MARKET_INDEX_UNREGISTER				= 58021,
////平安，向网关取消注册实时更新信息 request E_FID_PA_MARKET_INDEX_UNREGISTER
// 58021,平安，向网关取消注册实时更新信息
// xMarketIndexUnregisterReq
typedef xMarketIndexBaseReq_c xMarketIndexUnregisterReq_c;

//--E_FID_PA_MARKET_BOND_DESCRIPTION_REQ			= 58016,
////平安，请求，债市策略 request E_FID_PA_MARKET_BOND_DESCRIPTION_REQ
// 58016,平安，请求，债市策略
// xBondMarketStrategyReq
class xBondMarketStrategyReq_c : public xMarketIndexBaseReq_c {
 public:
  // Count
  int m_Count;  // 数量，-1表示全部请求
  // FunctionBegin
  // 初始值
  xBondMarketStrategyReq_c() { m_Count = -1; }
  // FunctionEnd
};

// inner
//
// 平安证券债市策略
// xBondMarketStrategy
class xBondMarketStrategy {
 public:
  // Flag
  int m_Flag;  // 1表示增加,2表示删除
  // ID
  int m_ID;  // 标识，唯一区分标志，服务端负责生成
  // Time
  time_t m_Time;  // 提交时间
  // Description
  char m_Description[4096];  // 债市策略
  // FunctionBegin
  // 初始值
  xBondMarketStrategy() {
    m_Flag = 0;
    m_ID = 0;
    m_Time = 0;
    _InitializeString(m_Description);
  }
  // FunctionEnd
};

//--E_FID_PA_MARKET_BOND_DESCRIPTION_SUBMIT			= 58018,
////平安，提交, 债市策略
//--平安证券债市策略请求

// request
// E_FID_PA_MARKET_BOND_DESCRIPTION_SUBMIT
// 58018,平安，提交, 债市策略
// xBondMarketStrategyListReq
class xBondMarketStrategyListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xBondMarketStrategy> m_List;
};

//--58018返回值为空，从返回消息头中获取是否成功

//--E_FID_PA_MARKET_BOND_DESCRIPTION_REQ			= 58016,
////平安，应答，债市策略
//--E_FID_PA_MARKET_BOND_DESCRIPTION_PUSH			= 58017,
////平安，推送，债市策略
//--平安证券债市策略应答

// response
// E_FID_PA_MARKET_BOND_DESCRIPTION_REQ,E_FID_PA_MARKET_BOND_DESCRIPTION_PUSH
// 58016,平安，应答，债市策略;58017,平安，推送，债市策略
// xBondMarketStrategyListAck
typedef xBondMarketStrategyListReq_c
    xBondMarketStrategyListAck_c;  // 平安证券债市策略应答

/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
// E_FID_GKH_INDEX_GKZ_REQ						= 58029,
// //国开行，请求，应答，国开指数 请求同58001 应答
class xGKHIndexGKZ {
 public:
  // Flag
  BYTE m_Flag;  // 标识，表示修改，表示增加，表示删除,此字段针对对向服务器发送
  // Time
  time_t m_Time;  // 日期
  // Value
  char m_Value[12];  // 指数

  xGKHIndexGKZ() {
    m_Flag = 0;
    m_Time = 0;
    _InitializeString(m_Value);
  }

  bool operator<(const xGKHIndexGKZ& obj) const {
    return this->m_Time < obj.m_Time;
  }
};

class xGKHIndexGKZListReq_c : public xMarketIndexBaseReq_c {
 public:
  // List
  std::list<xGKHIndexGKZ> m_List;  // 国开指数列表
};
typedef xGKHIndexGKZListReq_c xGKHIndexGKZListAck_c;

// E_FID_GKH_INDEX_GKZ_PUSH						= 58030,
// //国开行，推送，国开指数 无请求结构 应答同58029

// 58031,国开行,提交,国开指数：
// 请求使用58029的应答结构 xGKHIndexGKZListReq_c
// 应答结构 xMarketIndexBaseReq_c，判定ErrorCode

// E_FID_GKH_INDEX_DESCRIPTION_REQ					= 58032,
// //国开行，请求，应答，指标说明 请求应答同58013
// E_FID_GKH_INDEX_DESCRIPTION_PUSH				= 58033,
// //国开行，推送，指标说明 请求应答同58014 E_FID_GKH_INDEX_DESCRIPTION_SUBMIT
// = 58034,			//国开行，提交, 指标说明 请求应答同58015

// E_FID_GKH_INDEX_REGISTER						= 58035,
// //国开行，向网关注册实时更新信息，会向网关注册58030，58033，可以【重用】平安的请求结构体：xMarketIndexBaseReq_c
// E_FID_GKH_INDEX_UNREGISTER					= 58036,
// //国开行，向网关取消注册实时更新信息，可以【重用】平安的请求结构体：xMarketIndexBaseReq_c
// 请求应答同58020

/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
//--E_FID_QB_BOND_RELEASE_STAT_REQ				= 50550,
////发行统计

// request
// E_FID_QB_BOND_RELEASE_STAT_REQ
// 50550,发行统计
// xReleaseStatistReq
class xReleaseStatistReq_t {
 public:
  // Type
  char m_szType[64];  // 类型  对应于subtype 用“|”分割
  // IssueCode
  char m_szIssueCode[64];  // 发行人，仅适用国开/非国开
  // szType与IssueCode只能有一个有效，另一个填空
  // Range
  char m_szRange[256];  // 期限
  // Rate
  char m_szRate[64];  // 评级
  // Industry
  char m_szIndustry[128];  // 行业
  //		电力、		钢铁、		煤炭、		水泥、
  //房地产、	交运、		城投 匹配：GYS0201，	GTY0201，
  // CJY0202，	JZC0201，	FDC0101，	JTY0101，	Is_Municipal
  // EntCor
  char m_szEntCor[8];  // 公司类型
  // Begin
  time_t m_tBegin;
  // End
  time_t m_tEnd;
  // FunctionBegin
  // 初始值
  xReleaseStatistReq_t() {
    _InitializeString(m_szType);
    _InitializeString(m_szIssueCode);
    _InitializeString(m_szRange);
    _InitializeString(m_szRate);
    _InitializeString(m_szIndustry);
    _InitializeString(m_szEntCor);
    m_tBegin = 0;
    m_tEnd = 0;
  }
  // FunctionEnd
};

// inner
//
// 发行利率,发行量,一二级价差
// xStatistUnit
class xStatistUnit {
 public:
  // rate
  double m_rate;
  // volumn
  double m_volumn;
  // spread
  double m_spread;
  // AvgListedRate
  double m_AvgListedRate;
  // time
  time_t m_time;
  // FunctionBegin
  // 初始值
  xStatistUnit() {
    m_rate = 0.0f;
    m_volumn = 0.0f;
    m_spread = 0.0f;
    m_AvgListedRate = 0.0f;
    m_time = 0;
  }
  // FunctionEnd
};

// response
// E_FID_QB_BOND_RELEASE_STAT_REQ
// 50550,发行统计
// xReleaseStatistRateAck
class xReleaseStatistRateAck_t {
 public:
  // List
  std::list<xStatistUnit> m_List;
};

//--E_FID_QB_CTD_ANALYTIC_SERVUCE_REQ			= 50560,
////CTD分析
//
// 标志位
/*
//以下三个字段选一个发送，其它两个为返回值
//startFullPrice
double m_startFullPrice;                           // 现券全价
//startCleanPrice
double m_startCleanPrice;                          // 现券净价
//startYtm
double m_startYtm;                                 // 现券收益率
*/
enum CTD_STARTPRICE {
  STARTPRICE_NOTHING = 0,
  startFullPrice,
  startCleanPrice,
  startYtm
};
/*
//以下两个字段选一个发送，另一个为返回值
//futurePrice
double m_futurePrice;                              // 期货价格
//irr
double m_irr;                                      // 隐含回购利率
*/
enum CTD_FUTUREPRICE {
  FUTUREPRICE_NOTHING = 0,
  futurePrice,
  irr,
  basis,
  cleanBasis,
};
/*
//以下两个字段可能不发送
//fundingCostRate
double m_fundingCostRate;                          // 资金成本比率
//fundingCost
double m_fundingCost;                              // 资金成本额
*/
enum CTD_FUNDINGCOST { FUNDINGCOST_NOTHING = 0, fundingCost };
// inner
//
//
// value
class BondFutureMessage {
 public:
  // response:all

  // request&response
  // bondKey
  std::string m_bondKey;  // 债券key
  // listedMarket
  std::string m_listedMarket;  // listedMarket
  // convertFactor
  double m_convertFactor;  // 转换因子
  // futureSettlementDate
  std::string m_futureSettlementDate;  // 期货交割日
  // startDate
  std::string m_startDate;  // 建仓日,起始交易日

  // 以下三个字段选一个发送，其它两个为返回值
  CTD_STARTPRICE m_CTDStartPriceEnum;
  // startFullPrice
  double m_startFullPrice;  // 现券全价
  // startCleanPrice
  double m_startCleanPrice;  // 现券净价
  // startYtm
  double m_startYtm;  // 现券收益率

  // 以下两个字段选一个发送，另一个为返回值
  CTD_FUTUREPRICE m_CTDFuturePrice;
  // futurePrice
  double m_futurePrice;  // 期货价格
  // irr
  double m_irr;  // 隐含回购利率

  // 以下两个字段可能不发送
  CTD_FUNDINGCOST m_CTDFundingCost;
  // fundingCostRate
  double m_fundingCostRate;  // 资金成本比率
  // fundingCost
  double m_fundingCost;  // 资金成本额

  // response only
  // basis
  double m_basis;  // 基差
  // couponBetween
  double m_couponBetween;  // 期间付息
  // endAccruedAmount
  double m_endAccruedAmount;  // 交割日应计利息
  // invoicePrice
  double m_invoicePrice;  // 发票价格
  // startAccruedAmount
  double m_startAccruedAmount;  // 现券应计利息
  // timeWeightedCouponBetween
  double m_timeWeightedCouponBetween;  // 考虑时间的期间付息
  // holdingReturn
  double m_holdingReturn;  // 持有期收益
  // netBasis
  double m_netBasis;  // 净基差
  // futureSpotSpread
  double m_futureSpotSpread;  // 期现价差，2015/12/4，Add by lance
  // FunctionBegin
  // 初始值
  BondFutureMessage()
      : m_CTDStartPriceEnum(STARTPRICE_NOTHING),
        m_CTDFuturePrice(FUTUREPRICE_NOTHING),
        m_CTDFundingCost(FUNDINGCOST_NOTHING),
        m_startCleanPrice(0),
        m_startFullPrice(0),
        m_startAccruedAmount(0),
        m_startYtm(0),
        m_futurePrice(0),
        m_convertFactor(0),
        m_endAccruedAmount(0),
        m_couponBetween(0),
        m_timeWeightedCouponBetween(0),
        m_invoicePrice(0),
        m_irr(0),
        m_basis(0),
        m_fundingCostRate(0),
        m_fundingCost(0),
        m_holdingReturn(0),
        m_netBasis(0),
        m_futureSpotSpread(0) {
    m_bondKey = "";               // 债券key
    m_startDate = "";             // 建仓日,起始交易日
    m_futureSettlementDate = "";  // 期货交割日
    m_startDate = "";             // 建仓日,起始交易日
  }
  bool operator<(const BondFutureMessage& obj) const {
    int nRet = strcmp(m_startDate.c_str(), obj.m_startDate.c_str());
    return nRet < 0;
  }
  // FunctionEnd
};

// request
// E_FID_QB_CTD_ANALYTIC_SERVUCE_REQ
// 50560,CTD分析
// xCTDAnalyticServiceReq
class xCTDAnalyticServiceReq_c {
 public:
  // values
  std::list<BondFutureMessage> m_values;  // 计算条件与返回值列表
};

// response
// E_FID_QB_CTD_ANALYTIC_SERVUCE_REQ
// 50560,CTD分析
// xCTDAnalyticServiceAck
typedef xCTDAnalyticServiceReq_c xCTDAnalyticServiceAck_c;

//--E_FID_QB_BOND_QUOTE_INFO_TO_QM				= 50570,
////查询与设定标志位，标识QB中的债券行情变化是否推送到QM上

// request
// E_FID_QB_BOND_QUOTE_INFO_TO_QM
// 50570,查询与设定标志位，标识QB中的债券行情变化是否推送到QM上
// xBondQuoteInfoToQMReq
class xBondQuoteInfoToQMReq_c {
 public:
  // UserID
  char m_UserId[32 + 1];  // 用户id
  // UserName
  char m_UserName[64];  // 联系人帐号/QB登陆名/QM登陆名
  // Flag
  int m_Flag;  // 区间变动，是否推送。-1：向服务器发送为查询，返回时如果没有这个字段，以此为默认值，表示没有设置过；0：不推送；1：推送
  int m_BidConfirm;  // 投标确认，是否推送。-1：向服务器发送为查询，返回时如果为-1，表示没有设置过；0：不推送；1：推送
  int m_BidOutcome;  // 分配结果，是否推送。-1：向服务器发送为查询，返回时如果为-1，表示没有设置过；0：不推送；1：推送
  // FunctionBegin
  // 初始值
  xBondQuoteInfoToQMReq_c() {
    _InitializeString(m_UserId);
    _InitializeString(m_UserName);
    m_Flag = -1;
    m_BidConfirm = -1;
    m_BidOutcome = -1;
  }
  // FunctionEnd
};

// response
// E_FID_QB_BOND_QUOTE_INFO_TO_QM
// 50570,查询与设定标志位，标识QB中的债券行情变化是否推送到QM上
// xBondQuoteInfoToQMAck
typedef xBondQuoteInfoToQMReq_c xBondQuoteInfoToQMAck_c;

//--E_FID_QB_FIRST_PASSWORD_CHANGE				    = 59010,
////QB首次登陆强制密码修改， request E_FID_QB_FIRST_PASSWORD_CHANGE
// 59010,QB首次登陆强制密码修改
// xQBPasswordChangeReq
typedef struct xQBPasswordChangeReq_t {
  // UserID
  char m_UserID[32 + 1];  // QB用户ID
  // PWDChanged
  char m_PWDChanged
      [4];  // 是否已经设置：0：未设置，1：已经设置,；请求时此字段填-1；
  xQBPasswordChangeReq_t() {
    memset(m_UserID, 0, sizeof(m_UserID));
    memset(m_PWDChanged, 0, sizeof(m_PWDChanged));
  }
} QBPasswordChangeReq_t, *pQBPasswordChangeReq_t;

// 接收数据与请求一致
// response
// E_FID_QB_FIRST_PASSWORD_CHANGE
// 59010,QB首次登陆强制密码修改
// xQBPasswordChangeAck
typedef xQBPasswordChangeReq_t xQBPasswordChangeAck_c;

// Sumscope提醒助手 提醒方式： QM、弹窗提醒
class xReminderMessageModeReq_t {
 public:
  char m_UserID[32 + 1];   // QB用户ID
  char m_UserAccount[64];  // QB用户名
  char m_Type[33];         // 分类：债券、国债期货
  char m_SubType
      [33];  // 子分类：例如债券提醒：二级报价、二级成交、一级市场、债券日历和评级
  bool m_QM;         // QM提醒
  bool m_PopWindow;  // 弹窗提醒

  xReminderMessageModeReq_t() {
    memset(m_UserID, 0, sizeof(m_UserID));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_Type, 0, sizeof(m_Type));
    memset(m_SubType, 0, sizeof(m_SubType));

    m_QM = false;
    m_PopWindow = false;
  }
};

// E_FID_QB_REMINDER_MESSAGE_MODE_REQ           = 50610, //提醒方式：请求和返回
// E_FID_QB_REMINDER_MESSAGE_MODE_SUBMIT        = 50611, //提醒方式：提交和返回
typedef xReminderMessageModeReq_t xReminderMessageModeAck_c;

// E_FID_QB_REMINDER_CALENDAR_REQ           = 50612,
// //债券日历提前天数：请求和返回 E_FID_QB_REMINDER_CALENDAR_SUBMIT        =
// 50613,            //债券日历提前天数：提交和返回 债券提醒  债券日历
class xReminderMessageCalendarReq_t {
 public:
  char m_UserID[32 + 1];   // QB用户ID
  char m_UserAccount[64];  // QB用户名
  int m_PreDays;           // 提前天数

  xReminderMessageCalendarReq_t() {
    memset(m_UserID, 0, sizeof(m_UserID));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    m_PreDays = 0;
  }
};

// E_FID_QB_REMINDER_CALENDAR_REQ           = 50612,
// //债券日历提前天数：请求和返回 E_FID_QB_REMINDER_CALENDAR_SUBMIT        =
// 50613,            //债券日历提前天数：提交和返回
typedef xReminderMessageCalendarReq_t xReminderMessageCalendarAck_c;  // 应答

/*
E_FID_QB_REMINDER_IRSBOND_ADD_REQ			= 50630,
// 新增IRS现券价差提醒 E_FID_QB_REMINDER_IRSBOND_DEL_REQ   		= 50631,
// 删除IRS现券价差提醒 E_FID_QB_REMINDER_IRSBOND_MODIFY_REQ		= 50632,
// 修改IRS现券价差提醒 E_FID_QB_REMINDER_IRSBOND_QUERY_REQ
= 50633,			// 查询IRS现券价差提醒
*/
class xReminderIRSBondInfo {
 public:
  char m_ReminderId[33];   // 提醒Id
  char m_UserId[33];       // 用户Id
  char m_UserAccount[33];  // 用户名
  char m_CompanyId[4];     // 经纪商Id
  char m_GoodsCode[16];    // irs goodscode
  char m_TypeName[32];     // irs typename
  char m_TermName[16];     // irs termName
  char m_BondKey[33];      // bond bondkey
  char m_ListedMarket[8];  // bond listedMarket
  int m_Symbol;            // 条件 -1-ofr 1-bid
  int m_Condition;         // 比较符号 0-大于等于 1-小于等于
  double m_Threshold;      // 比较阈值
  time_t m_Time;           // 关注时间
  int m_ReminderType;      // 1、现券价差提醒  2， 价格提醒
  xReminderIRSBondInfo()
      : m_Symbol(-1),
        m_Condition(0),
        m_Threshold(0.0),
        m_Time(0),
        m_ReminderType(0) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_CompanyId, 0, sizeof(m_CompanyId));
    memset(m_GoodsCode, 0, sizeof(m_GoodsCode));
    memset(m_TypeName, 0, sizeof(m_TypeName));
    memset(m_TermName, 0, sizeof(m_TermName));
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
  }
};

class xReminderIRSBondInfoList {
 public:
  std::list<xReminderIRSBondInfo> m_List;
};

// E_FID_QB_REMINDER_IRSBOND_PUSH				= 50634
// IRS现券价差提醒满足条件推送，弹框 E_FID_QB_REMINDER_IRSPRICE_PUSH
// = 50635,			// IRS价格提醒满足条件推送，弹框
class xReminderIRSBondMsg {
 public:
  xReminderIRSBondInfo m_ReminderInfo;
  double m_Value;
  xReminderIRSBondMsg() : m_Value(0.0) {}
};

class xReminderAddAckEx_c {
 public:
  char m_ReminderId[33];  // ReminderID
  time_t m_Time;          // 关注时间
  xReminderAddAckEx_c() : m_Time(0) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
  }
};

/*
E_FID_QB_REMINDER_NATDEBT_ADD_REQ           = 50650,			//
新增国债期货提醒 E_FID_QB_REMINDER_NATDEBT_DEL_REQ           = 50651,
// 删除国债期货提醒 E_FID_QB_REMINDER_NATDEBT_MODIFY_REQ		= 50652,
// 修改国债期货提醒
*/
class xReminderNatDebtInfo {
 public:
  char m_ReminderId[33];   // 提醒Id
  char m_UserId[33];       // 用户Id
  char m_UserAccount[64];  // 用户名
  int m_ReminderType;  // 国债期货提醒类型，0-IRR 1-基差提醒 2-期现价差提醒
                       // 3-期货价差提醒
  char m_TFID[8];          // 资产1 期货合约
  char m_BondKey[33];      // 资产2 bondkey
  char m_ListedMarket[8];  // 资产2 listedMarket
  int m_BondType;  // 资产2 债券类型 0-指定债券 1-最优CTD 1-次优CTD
  char m_TFIDSecond[8];  // 资产2 期货合约
  int m_QuoterType;      // 报价来源 0-all 1-仅经纪商 2-仅交易所
  int m_Condition;       // 条件
  /*
  IRR提醒      0-OfrIRR            1-BidIRR            2-成交价IRR
  基差提醒     0-Ofr基差           1-Bid基差           2-成交价基差 3-Ofr净基差
  4-Bid净基差 5-成交价净基差 期现价差     0-Ofr期现价差       1-Bid期现价差
  2-成交价期现价差 期货价差     0-Ofr价差           1-Bid价差 2-成交价价差
  */
  int m_ConditionSymbol;  // 比较符号 0-大于等于 1-小于等于
  double m_Threshold;     // 比较阈值
  int m_ThresholdUnit;  // 0-正常单位（比较阈值即为最终比较值） 1-标准差σ
  char m_StartDate[9];  // 单位为σ时使用，用于计算标准差的开始时间
  time_t m_Time;        // Reminder被创建或编辑的时间

  xReminderNatDebtInfo()
      : m_ReminderType(0),
        m_BondType(0),
        m_QuoterType(0),
        m_Condition(0),
        m_ConditionSymbol(0),
        m_Threshold(0.0),
        m_ThresholdUnit(0),
        m_Time(0) {
    memset(m_ReminderId, 0, sizeof(m_ReminderId));
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_TFID, 0, sizeof(m_TFID));
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_TFIDSecond, 0, sizeof(m_TFIDSecond));
    memset(m_StartDate, 0, sizeof(m_StartDate));
  }
};

class xReminderNatDebtInfoList {
 public:
  std::list<xReminderNatDebtInfo> m_List;
};

// E_FID_QB_REMINDER_NATDEBT_QUERY_REQ			= 50653,
// // 查询国债期货提醒
class xReminderNatDebtReq_t {
 public:
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  int m_ReminderType;  // 国债期货提醒类型，0-IRR 1-基差提醒 2-期现价差提醒
                       // 3-期货价差提醒
  time_t m_BeginTime;  // 开始时间	-1，从最早开始
  time_t m_EndTime;    // 结束时间	-1，到最新
  xReminderNatDebtReq_t() : m_BeginTime(-1), m_EndTime(-1), m_ReminderType(0) {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
};

// E_FID_QB_REMINDER_NATDEBT_PUSH=50654 国债期货提醒满足条件推送，弹框
class xReminderNatDebtMsg {
 public:
  xReminderNatDebtInfo m_ReminderInfo;
  double m_Value;
  xReminderNatDebtMsg() : m_Value(0.0) {}
};

// E_FID_QB_NOTICE_AMS_REQ	= 50656,			//
// 请求QB打开WebQB状态 无请求结构 应答
struct xQBNoticeAMSMsgAck_c {
 public:
  int m_Flag;           // 1=ShowWebQB, 2=Closed
  char m_Title[128];    // 标题
  char m_Content[512];  // 内容
  xQBNoticeAMSMsgAck_c() { memset(this, 0, sizeof(xQBNoticeAMSMsgAck_c)); };
};
// E_FID_QB_NOTICE_AMS_PUSH = 50657,			//
// AMS对QB推送打开WebQB的通知 无须请求，应答同50656

// E_FID_QB_HISSPREAD_KLINE_REQ                = 50620,			//
// 历史价差日线数据
// E_FID_QB_HISSPREAD_ACFIN_BOND_KLINE_REQ      = 50621, //
// 历史价差活跃金融债日线数据,请求应答同50620
class xQBHisSpreadReq_c {
 public:
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  char m_TF_ID[8];         // 期货合约
  time_t m_BeginTime;  // 开始时间 -1为最早, 使用日期请求某天，命名有歧义
  time_t m_EndTime;  // 结束时间 -1为最晚，使用日期请求某天，命名有歧义
  bool m_IsActiveCTD;  // 4.8新增是否是请求历史CTD，不填默认为false
  bool m_IsHistoryCTD;  // 4.3新增，不填默认为false; 4.3新增的历史CTD计算
  xQBHisSpreadReq_c()
      : m_BeginTime(0),
        m_EndTime(0),
        m_IsActiveCTD(false),
        m_IsHistoryCTD(false) {
    memset(m_bondKey, 0, sizeof(m_bondKey));
    memset(m_listedMarket, 0, sizeof(m_listedMarket));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
};

class xQBHisSpreadUnit_c {
 public:
  char m_bondKey[33];                  // bondkey
  char m_listedMarket[4];              // listedMarket
  char m_TF_ID[8];                     // 期货合约
  UINT m_Date;                         // 时间
  double m_bondPrice;                  // 现券成交收益率
  double m_cleanPrice;                 // 现券成交净价
  double m_fullPrice;                  // 现券成交全价
  double m_futurePrice;                // 期货结算价
  double m_invoicePrice;               // 发票价格
  double m_basis;                      // 基差
  double m_spotSpread;                 // 期现价差
  double m_IRR;                        // IRR
  double m_timeWeightedCouponBetween;  // 考虑时间的期间付息
  double m_couponBetween;              // 期间付息付息
  double m_startAccruedAmount;         // 现券应计利息
  double m_endAccruedAmount;           // 交割日应计利息
  double m_netBasis;  // 额外增加的净基差字段，方便计算
  char m_BondID[12];  // 2.8新增，bond ID、bond code;     唯一,除非为空
  double m_convertFactor;   // 2.8新增，转换因子
  double m_CDC_CleanPrice;  // 2.8新增，中债估值净价
  double
      m_tf_irr;  // 3.1新增，期货隐含收益率，m_isCTD为1时计算，期货隐含收益率,持有期收益
  double m_CDC_Ytm;  // 3.3新增，中债估值收益率

  xQBHisSpreadUnit_c()
      : m_bondPrice(0.0),
        m_cleanPrice(0.0),
        m_fullPrice(0.0),
        m_futurePrice(0.0),
        m_invoicePrice(0.0),
        m_basis(0.0),
        m_spotSpread(0.0),
        m_IRR(0.0),
        m_timeWeightedCouponBetween(0.0),
        m_couponBetween(0.0),
        m_startAccruedAmount(0.0),
        m_endAccruedAmount(0.0),
        m_Date(0),
        m_netBasis(0),
        m_convertFactor(0.0),
        m_CDC_CleanPrice(0.0),
        m_tf_irr(0.0),
        m_CDC_Ytm(0.0) {
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
    _InitializeString(m_TF_ID);
    _InitializeString(m_BondID);
  }
  bool operator<(const xQBHisSpreadUnit_c& obj) const {
    return m_Date < obj.m_Date;
  }
};

class xQBHisSpreadAck_c {
 public:
  std::list<xQBHisSpreadUnit_c> m_List;
};

// E_FID_QB_BOND_ACTIVE_MATRIX_KLINE_REQ       = 50622,            //
// 活跃及次活跃债 日线信息查询 E_FID_QB_BOND_ACTIVE_MATRIX_KLINE_CDH_REQ
// = 50623,			// 活跃债及次活跃债 日线信息 CDH相关序列2

class xQBBondActiveMatrixReq_c {
 public:
  char m_bondType[8];  // 类型，国债，国开，口行，农发和地方债
  char m_maturity[7];  // 期限，以Y1， Y3， Y5， Y7，Y10给到
  int m_activeLevel;  // 活跃排位，0表示最活跃券，1表示次活跃券, 2表示不活跃券
  time_t m_BeginTime;  // 开始时间 -1为最早
  time_t m_EndTime;    // 结束时间 -1为最晚

  xQBBondActiveMatrixReq_c()
      : m_BeginTime(-1), m_EndTime(-1), m_activeLevel(-1) {
    _InitializeString(m_bondType);
    _InitializeString(m_maturity);
  }
};

class xQBBondActiveMatrixUnit_c {
 public:
  UINT m_Date;              // 时间 (e.g. 20180130 )
  char m_BondID[12];        // BondId
  char m_listedMarket[4];   // listedMarket
  char m_bondKey[33];       // bondkey
  double m_CDC_Ytm;         // 中债估值收益率
  double m_CDC_CleanPrice;  // 中债估值净价
  double m_avgPriceYtm;     // 均价，收益率
  double m_closePriceYtm;   // 收盘价，收益率
  xQBBondActiveMatrixUnit_c()
      : m_Date(0),
        m_CDC_Ytm(0.0),
        m_CDC_CleanPrice(0.0),
        m_avgPriceYtm(0.0),
        m_closePriceYtm(0.0) {
    _InitializeString(m_BondID);
    _InitializeString(m_listedMarket);
    _InitializeString(m_bondKey);
  }

  bool operator<(const xQBBondActiveMatrixUnit_c& obj) const {
    return m_Date < obj.m_Date;
  }
};

class xQBBondActiveMatrixAck_c {
 public:
  std::list<xQBBondActiveMatrixUnit_c> m_List;
};

// E_FID_QB_HISSPREAD_ACTIVE_SCHEME_REQ  = 50624,
// //QB历史价差_序列存储方案查询
typedef xQBBasicRequestWithUser xQBHisSpreadActiveSchemeReq;

struct xQBHisSpreadActiveSchemeAck {
  char m_userId[32 + 1];
  char m_selType[4];  //"0"或者“”表示默认序列（从后台获取），
                      //"1"表示新序列（从CDH获取);查不到该用户的方案是返回空
  xQBHisSpreadActiveSchemeAck() {
    _InitializeString(m_userId);
    _InitializeString(m_selType);
  }
};

// E_FID_QB_HISSPREAD_ACTIVE_SCHEME_MDY		= 50625,
// //QB历史价差_活跃券序列方案修改

// 请求 xQBHisSpreadActiveSchemeMdyReq
typedef xQBHisSpreadActiveSchemeAck xQBHisSpreadActiveSchemeMdyReq;

// 应答xQBHisSpreadActiveSchemeMdyAck
// 应答需要返回对应的请求内容，QB在收到方案修改成功的应答后才会对界面数据做重取操作
typedef xQBHisSpreadActiveSchemeMdyReq xQBHisSpreadActiveSchemeMdyAck;

// E_FID_QB_HISSPREAD_CONVERT_FACTOR_REQ       = 50339,
// //历史价差转换因子计算请求 FE
class xConvertFactorsUnit_c {
 public:
  char m_bondKey[33];       // bondKey
  char m_deliverDate[13];   // deliverDate交割日
  double m_convertFactors;  // 请求时不填参数，应答时接参数
  xConvertFactorsUnit_c() : m_convertFactors(0.0) {
    memset(m_bondKey, 0, sizeof(m_bondKey));
    memset(m_deliverDate, 0, sizeof(m_deliverDate));
  }
};
// 请求
class xConvertFactorsReq_c {
 public:
  std::list<xConvertFactorsUnit_c> m_List;
};
// 应答
class xConvertFactorsAck_c {
 public:
  std::list<xConvertFactorsUnit_c> m_List;
};
// E_FID_QB_TDYSPREAD_SPREAD_PRE_CLOSE			= 50626,
// //QB当日价差，请求利差昨结基础数据

struct SpreadTFUnit {
  char m_tf_id[8];       // 期货合约
  double m_futurePrice;  // 期货结算价; 请求的时候不填写该字段
  SpreadTFUnit() : m_futurePrice(0.0) { _InitializeString(m_tf_id); }
};
struct SpreadBondUnit {
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  double m_bondPrice;  // 现券成交收益率;请求的时候不填写该字段
  double m_cleanPrice;   // 现券成交净价;请求的时候不填写该字段
  double m_fullPrice;    // 现券成交全价;请求的时候不填写该字段
  double m_futurePrice;  // 期货结算价;请求的时候不填写该字段
  SpreadBondUnit()
      : m_bondPrice(0.0), m_cleanPrice(0.0), m_fullPrice(0), m_futurePrice(0) {
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
  }
};

class xQBTdySpreadSpreadPreCloseReq {
 public:
  time_t m_req_time;  // 请求时间,需要往前取有交集的那天的结算价
  std::list<SpreadTFUnit> m_listTF;
  std::list<SpreadBondUnit> m_listBond;
  xQBTdySpreadSpreadPreCloseReq() : m_req_time(0) {}
};

class xQBTdySpreadSpreadPreCloseAck {
 public:
  UINT m_date;  // 时间; 保证应答的价格list同属于同一天
  std::list<SpreadTFUnit> m_listTF;
  std::list<SpreadBondUnit> m_listBond;

  xQBTdySpreadSpreadPreCloseAck() : m_date(0) {}
};

// E_FID_QB_TDYSPREAD_BASIS_PRE_CLOSE = 50627,
// //QB当日价差，请求基差，净基差，IRR，期现价差昨结
class xQBTdySpreadBasisPreCloseReq {
 public:
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  char m_tf_id[8];         // 期货合约
  time_t m_req_time;       // 请求时间,需要往前取结算价
  xQBTdySpreadBasisPreCloseReq() : m_req_time(0) {
    memset(m_bondKey, 0, sizeof(m_bondKey));
    memset(m_listedMarket, 0, sizeof(m_listedMarket));
    memset(m_tf_id, 0, sizeof(m_tf_id));
  }
};

class xQBTdySpreadBasisPreCloseAck {
 public:
  char m_bondKey[33];                  // bondkey
  char m_listedMarket[4];              // listedMarket
  char m_tf_id[8];                     // 期货合约
  UINT m_date;                         // 时间
  double m_bondPrice;                  // 现券成交收益率
  double m_cleanPrice;                 // 现券成交净价
  double m_fullPrice;                  // 现券成交全价
  double m_futurePrice;                // 期货结算价
  double m_invoicePrice;               // 发票价格
  double m_basis;                      // 基差
  double m_spotSpread;                 // 期现价差
  double m_irr;                        // IRR
  double m_timeWeightedCouponBetween;  // 考虑时间的期间付息
  double m_couponBetween;              // 期间付息付息
  double m_startAccruedAmount;         // 现券应计利息
  double m_endAccruedAmount;           // 交割日应计利息
  double m_convertFactor;              // 转换因子
  double m_netBasis;  // 额外增加的净基差字段，方便计算

  xQBTdySpreadBasisPreCloseAck()
      : m_bondPrice(0.0),
        m_cleanPrice(0.0),
        m_fullPrice(0.0),
        m_futurePrice(0.0),
        m_invoicePrice(0.0),
        m_basis(0.0),
        m_spotSpread(0.0),
        m_irr(0.0),
        m_timeWeightedCouponBetween(0.0),
        m_couponBetween(0.0),
        m_startAccruedAmount(0.0),
        m_endAccruedAmount(0.0),
        m_date(0),
        m_netBasis(0),
        m_convertFactor(0.0) {
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
    _InitializeString(m_tf_id);
  }
};

// E_FID_QB_NAT_DEBT_ACTIVE_BOND_REQ           = 50654, //查询国债期货的活跃券
class xNatDebtActiveBondReq_t {
 public:
  xNatDebtActiveBondReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
};

class xNatDebtActiveBondAck_c {
 public:
  std::list<TW_BOND> m_ListFive;
  std::list<TW_BOND> m_ListTen;
  std::list<TW_BOND> m_ListTwo;
};

// E_FID_QB_NAT_DEBT_DEAL_TF_PRICE             = 50666,
// //批量查询某一成交时刻国债期货价格
class xNatDebtDealTFPrc_Unit_c {
 public:
  xNatDebtDealTFPrc_Unit_c() : m_Time(-1) {
    memset(m_price, 0, sizeof(m_price));
  }
  time_t m_Time;     // 时间
  char m_price[12];  // 国债期货价格
};

class xNatDebtDealTFPrc_Unit {
 public:
  xNatDebtDealTFPrc_Unit() {
    memset(m_TF_Key, 0, sizeof(m_TF_Key));
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
  char m_TF_Key[32 + 1];  // 国债期货编码
  char m_TF_ID[8];        // 期货代码
  std::list<xNatDebtDealTFPrc_Unit_c> m_List;
};

class xNatDebtDealTFPrc_Req_t {
 public:
  std::list<xNatDebtDealTFPrc_Unit> m_List;
};

// xNatDebtDealTFPrc_Req_t 应答同请求 ： 请求中Price不填

// E_FID_QB_TF_HIS_FLUCTUATION_REQ = 50667,            //查询历史波动率
class xNatDebtTF_His_Fluctuation_Unit {
 public:
  xNatDebtTF_His_Fluctuation_Unit() : m_Time(0) {
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
  char m_TF_ID[8];  // 期货代码
  time_t m_Time;    // 传上一个工作日的时间
};

class xNatDebtTF_His_Fluctuation_Req_t {
 public:
  std::list<xNatDebtTF_His_Fluctuation_Unit> m_List;
};

// E_FID_QB_TF_HIS_FLUCTUATION_REQ 应答  //查询历史波动率
class xNatDebtTF_His_Fluctuation_info_c {
 public:
  xNatDebtTF_His_Fluctuation_info_c()
      : m_Week(0.0f),
        m_OneMonth(0.0f),
        m_TwoMonth(0.0f),
        m_ThreeMonth(0.0f),
        m_SixMonth(0.0f),
        m_NineMonth(0.0f),
        m_OneYear(0.0f),
        m_All(0.0f) {
    memset(m_TF_ID, 0, sizeof(m_TF_ID));
  }
  char m_TF_ID[8];     // 期货代码
  float m_Week;        // 过去一周
  float m_OneMonth;    // 过去一个月
  float m_TwoMonth;    // 过去两个月
  float m_ThreeMonth;  // 过去三个月
  float m_SixMonth;    // 过去六个月
  float m_NineMonth;   // 过去九个月
  float m_OneYear;     // 过去1年
  float m_All;         // 上市以来
};

class xNatDebtTF_His_Fluctuation_Ack_c {
 public:
  std::list<xNatDebtTF_His_Fluctuation_info_c> m_List;
};

// E_FID_QB_NAT_DEBT_CUSTOM_BOND_REQ           = 50655, //查询国债期货的自选券
class xNatDebtCustomBondReq_t {
 public:
  xNatDebtCustomBondReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
  char m_UserId[32 + 1];                // 用户id
  char m_UserAccount[64];               // 用户名
  std::list<xQBTFInstrument_c> m_List;  // 合约列表 ,其中传入参数为合约代码
};

class xNatDebtCustomBondUnit_c {
 public:
  xNatDebtCustomBondUnit_c() {
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
  }
  char m_InstrumentID[8];     // 合约代码
  std::list<TW_BOND> m_List;  // 债券列表
};

class xNatDebtCustomBondAck_c {
 public:
  std::list<xNatDebtCustomBondUnit_c> m_List;
};

// E_FID_QB_NAT_DEBT_ADD_CUSTOM_BOND_REQ       = 50656, //添加国债期货的自选券
class xNatDebtAddCustomBondReq_t {
 public:
  xNatDebtAddCustomBondReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
  }
  char m_UserId[32 + 1];      // 用户id
  char m_UserAccount[64];     // 用户名
  char m_InstrumentID[8];     // 合约代码
  std::list<TW_BOND> m_List;  // 债券列表,防止需要批量添加
};
// 没有应答,只返回ERROR CODE

// E_FID_QB_NAT_DEBT_REMOVE_CUSTOM_BOND_REQ    = 50657, //删除国债期货的自选券
class xNatDebtRemoveCustomBondReq_t {
 public:
  xNatDebtRemoveCustomBondReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_InstrumentID, 0, sizeof(m_InstrumentID));
  }
  char m_UserId[32 + 1];      // 用户id
  char m_UserAccount[64];     // 用户名
  char m_InstrumentID[8];     // 合约代码
  std::list<TW_BOND> m_List;  // 债券列表,防止需要批量删除
};
// 没有应答,只返回ERROR CODE

// 新版成交统计Bond Deal基础数据结构
class xQBDealAttnGroupUnit_c {
 public:
  char m_GroupName[32];    // 分类名
  char m_GroupId[32 + 1];  // 分类Id
  xQBDealAttnGroupUnit_c() {
    memset(m_GroupName, 0, sizeof(m_GroupName));
    memset(m_GroupId, 0, sizeof(m_GroupId));
  }
};
class xQBDealAttnGroupInfo_c {
 public:
  xQBDealAttnGroupUnit_c m_AttnUnit;  // 关注分组名和分类Id
  std::list<TW_BOND> m_List;          // 成交统计关注列表数据
};
////////////////////////////////1////////////////////////////////////////
// 成交统计关注查询  E_FID_QB_DEAL_ATTN_QRY
// 请求Req
typedef xQBBasicRequestWithUser xQBDealAttnQryReq_c;

// 应答Ack
class xQBDealAttnInfoListAck_c {
 public:
  std::list<xQBDealAttnGroupInfo_c> m_GroupList;  // 我的关注分类列表数据
};

//////////////////////////////2///////////////////////////////////////
// 成交统计关注分类修改
// 关注分类增加 E_FID_QB_DEAL_ATTN_GROUP_MDF_ADD //有应答结构
// 请求Req
class xQBDealAttnGroupMdfReq_c {
 public:
  char m_UserId[32 + 1];  // 用户Id
  int m_nMdfType;  //-1表示无效,0表示关注分类增加，1表示关注分类删除，2表示分类名修改
  std::list<xQBDealAttnGroupUnit_c>
      m_MdyList;  // 分类名  //情况0 2时需要填写 1时为空
  // 分类Id //情况1 2需要填写  0时为空
  xQBDealAttnGroupMdfReq_c() {
    memset(m_UserId, 0, sizeof(m_UserId));
    m_nMdfType = -1;
  }
};
// 应答Ack //当m_nMdfType==0的时候需要有应答，其它返回ERROR_CODE即可
// 应答包含的是插入的分组名和groupid的对应关系
class xQBDealAttnGroupMdfAck_c {
 public:
  std::list<xQBDealAttnGroupUnit_c> m_GroupBasicList;  // 我的关注分类数据
};
////////////////////////////3/////////////////////////////////////////
// 成交统计关注具体分类下债券列表增删修改E_FID_QB_DEAL_ATTN_BOND_LIST__MDF
// 请求Req
class xQBDealAttnBondListMdfReq_c {
 public:
  char m_UserId[32 + 1];   // 用户Id
  char m_GroupId[32 + 1];  // 分类Id
  int m_nMdfType;  // 债券列表修改类型，-1表示无效,0表示增加，1表示删除
  std::list<TW_BOND> m_List;  // 债券信息列表
  xQBDealAttnBondListMdfReq_c() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_GroupId, 0, sizeof(m_GroupId));
    m_nMdfType = -1;
  }
};

// 无应答，返回ERROR_CODE

// 成交统计国债期货相关券行情查询 E_FID_QB_DEAL_TF_RELEVANT_STREAM_REQ 50253
// 请求Req
class xQBDealTFRelevantStreamReq_c {
 public:
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据, 只会填写BrokerID
};

// 应答Ack
class xQBDealTFRelevantStreamUnit_c {
 public:
  char m_company_id[4];     // 经纪公司ID', 推送过滤使用
  char m_operate[5];        // 消息子类，成交形式
  char m_status[5];         // 2--无效，无效时客户端删除成交
  char m_id[32 + 1];        // 唯一编号,删除时使用
  char m_bondkey[32 + 1];   // key
  char m_listedmarket[8];   // 市场代码
  char m_price[12];         // 成交价，收益率
  char m_Main_TF_ID[8];     // 主力期货合约
  char m_futurePrice[32];   // 期货价格
  double m_convertFactors;  // 转换因子
  char m_IRR[32];           // IRR
  char m_basis[32];         // 基差
  char m_netBasis[32];      // 净基差
  time_t m_createTime;      // 成交时间
  int m_nStreamBondType;    // 显示辅助用表示券类型，默认为-1

  double m_couponBetween;              // 期间付息
  double m_endAccruedAmount;           // 交割日应计利息
  double m_startAccruedAmount;         // 现券应计利息
  double m_startFullPrice;             // 现券全价
  double m_timeWeightedCouponBetween;  // 考虑时间的期间付息
  xQBDealTFRelevantStreamUnit_c()
      : m_convertFactors(0.0),
        m_couponBetween(0.0),
        m_endAccruedAmount(0.0),
        m_startAccruedAmount(0.0),
        m_startFullPrice(0.0),
        m_timeWeightedCouponBetween(0.0),
        m_createTime(0),
        m_nStreamBondType(-1) {
    _InitializeString(m_company_id);
    _InitializeString(m_operate);
    _InitializeString(m_status);
    _InitializeString(m_id);
    _InitializeString(m_bondkey);
    _InitializeString(m_listedmarket);
    _InitializeString(m_price);
    _InitializeString(m_Main_TF_ID);
    _InitializeString(m_futurePrice);
    _InitializeString(m_IRR);
    _InitializeString(m_basis);
    _InitializeString(m_netBasis);
  }
  const bool operator<(const xQBDealTFRelevantStreamUnit_c& obj) const {
    return m_createTime > obj.m_createTime;
  }
};

class xQBDealTFRelevantStreamAck_c {
 public:
  std::list<xQBDealTFRelevantStreamUnit_c> m_List;  // 国债期货相关券基差计算结果
};

// E_FID_QB_DEAL_ACTIVE_FINANCIAL_BOND_REQ     = 50255, //活跃金融债查询 请求Req
class xQBDealActiveFinancialBondReq_c {
 public:
  UINT m_reqDate;  // 20160812, 设成0或者不设都表示今天
  xQBDealActiveFinancialBondReq_c() : m_reqDate(0) {}
};

struct xQBDealActiveFinancialBondUnit_t {
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  int m_nTransCount;       // 成交笔数
  xQBDealActiveFinancialBondUnit_t() : m_nTransCount(0) {
    _InitializeString(m_bondkey);
    _InitializeString(m_listedmarket);
  }
};
// 应答Ack
class xQBDealActiveFinancialBondAck_c {
 public:
  std::list<xQBDealActiveFinancialBondUnit_t> m_List;
};

// 成交统计查询期限范围 REQ  E_FID_QB_DEAL_TERM_RANGE_REQ
// = 50258,            //成交统计查询期限范围
struct sBondDealTermRgUnit {
  char m_term[12];       // 期限类型  1Y 2Y 3Y 1M
  char m_rangeLeft[12];  // 区间左      1.5Y 2Y 3Y
                         // //请求时会填入默认区间,如果查询不到,则原数据返回。
  char m_rangeRight[12];  // 区间右
  int m_nCol;             // 所在列
  int m_daysLeft;         // 下限
  int m_daysRight;        // 上限
};

struct sBondDealTermList {
  sBondDealTermList() : m_nRate(-1), m_diffType(-1) {}
  int m_nRate;  // 0 利率债，1信用债, 2 NCD-1无效数据
  std::list<sBondDealTermRgUnit> m_listTerm;  // 期限列表
  int m_diffType;  // 涨跌bp，0昨收，1中债，-1默认
};

class xQBBondDealTermRgReq {
 public:
  xQBBondDealTermRgReq() {
    _InitializeString(m_UserId);
    _InitializeString(m_UserAccount);
    m_TextShowType = 0;
    m_ChartShowType = 0;
    m_bChangeTermRange = false;
  }
  char m_UserId[32 + 1];   // 用户id
  char m_UserAccount[64];  // 用户名
  std::list<sBondDealTermList>
      m_matrixTerm;    // 传递含list的list，目前计算暂无分包
  int m_TextShowType;  // 文字展示，0收益率，1bp
  int m_ChartShowType;  // 图形展示，0热力图，1横向柱状图，2纵向柱状图
  bool m_bChangeTermRange;
};

class xQBBondDealTermRgAck {
 public:
  xQBBondDealTermRgAck() {}
  std::list<sBondDealTermList> m_matrixTerm;
};

// E_FID_QB_DEAL_TERM_RANGE_MODIFY				= 50259,
// //成交统计修改期限范围 请求应答同 50258

// 成交统计国债期货相关券行情推送 E_FID_QB_DEAL_TF_RELEVANT_STREAM_PUSH 50254
//
// 应答结构同上
// 目前暂定由客户端接所有推送，然后通过companyID过滤显示

// E_FID_QB_MOBILE_VERIFY_INFO = 53223,            //获取手机验证信息
typedef xQBBasicRequestWithUser xQBMobileVerifyInfoReq_c;

// 应答Ack
class xQBMobileVerifyInfoAck_c {
 public:
  bool m_verifyMobile;  // 是否已经验证
  char m_mobile[16];    // 验证的手机号
  char m_time[16];      // 验证时间
  int m_restTimes;      // 剩余点击次数
  int m_verifyHour;     // 验证时间  整点
  xQBMobileVerifyInfoAck_c() {
    memset(m_mobile, 0, sizeof(m_mobile));
    memset(m_time, 0, sizeof(m_time));
    m_verifyMobile = false;
    m_restTimes = 0;
    m_verifyHour = 12;
  }
  virtual ~xQBMobileVerifyInfoAck_c() { ; }
};

// E_FID_QB_MOBILE_SEND_MESSAGE				= 53224, //发送验证码
class xQBMobileSendMessageReq_c {
 public:
  char m_UserId[32 + 1];  // 用户ID
  char m_mobile[16];      // 手机号码
  xQBMobileSendMessageReq_c() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_mobile, 0, sizeof(m_mobile));
  }
};

// 应答Ack
class xQBMobileSendMessageAck_c {
 public:
  char m_mobile[16];  // 手机号码
  int m_data;  // 验证情况  0-成功,1-手机号已经绑定,2-手机验证码发送失败.

  xQBMobileSendMessageAck_c() {
    memset(m_mobile, 0, sizeof(m_mobile));
    m_data = 0;
  }
};

// E_FID_QB_MOBILE_VERIFY_MESSAGE = 53225,            //验证手机验证码
class xQBMobileVerifyMessageReq_c {
 public:
  char m_UserId[32 + 1];        // 用户ID
  char m_mobile[16];            // 手机号码
  char m_vefifycationCode[10];  // 验证码
  xQBMobileVerifyMessageReq_c() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_mobile, 0, sizeof(m_mobile));
    memset(m_vefifycationCode, 0, sizeof(m_vefifycationCode));
  }
};

// 应答Ack
class xQBMobileVerifyMessageAck_c {
 public:
  bool m_data;  // 验证情况
  xQBMobileVerifyMessageAck_c() { m_data = false; }
};

// E_FID_QB_MOBILE_VERIFY_NEST_TIMES = 53226,            //下次再说
typedef xQBBasicRequestWithUser xQBMobileVerifyNextTimesReq_c;

// 应答Ack
class xQBMobileVerifyNextTimesAck_c {
 public:
  int m_data;  // 剩余点击次数

  xQBMobileVerifyNextTimesAck_c() { m_data = 0; }
};

// E_FID_QB_MOBILE_MODIFY_USEINFO = 53227,            //修改手机验证用户信息
class xQBMobileModifyUserInfoReq_c {
 public:
  char m_UserId[32 + 1];    // 用户ID
  char m_companyName[64];   // 机构
  char m_dept[64];          // 部门
  char m_title[64];         // 职位
  char m_tel[64];           // 固话
  char m_qq[64];            // QQ
  char m_businessType[64];  // 业务类型
  xQBMobileModifyUserInfoReq_c() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_companyName, 0, sizeof(m_companyName));
    memset(m_dept, 0, sizeof(m_dept));
    memset(m_title, 0, sizeof(m_title));
    memset(m_tel, 0, sizeof(m_tel));
    memset(m_qq, 0, sizeof(m_qq));
    memset(m_businessType, 0, sizeof(m_businessType));
  }
};

// 应答Ack
class xQBMobileModifyUserInfoAck_c {
 public:
  bool m_data;  // 应答情况,暂时不需要使用,不管是否成功

  xQBMobileModifyUserInfoAck_c() { m_data = false; }
};

//--------------------------------------------------------------------------------------------------
// E_FID_ORIGINAL_QUOTE_REQ						= 61050,
// //请求基本报价
struct xQBOriginalQuoteRequest_t {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
  char m_bondkey[32 + 1];                // bondkey
  char m_listedmarket[8];                // 市场代码
  time_t m_starttime;                    // 开始时间
  time_t m_endtime;  // 结束时间，-1表示结束时间无效
  int m_limit;       // 限制条数，-1表示限制条数无效
  xQBOriginalQuoteRequest_t() : m_starttime(0), m_endtime(-1), m_limit(-1) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
  }
};

struct OriginalQuoteInfo {
  char m_company_id[4];             // 经纪公司ID',
  char m_bondkey[32 + 1];           // 产品ID',
  char m_listedmarket[8];           // 市场代码
  char m_id[32 + 1];                // id
  int m_createTime;                 // 创建时间
  int m_modifyTime;                 // 修改时间
  char m_dealStatus[2];             // 交易状态
  char m_rateType[32 + 1];          // 利率方式
  char m_flagBargain[8];            // 议价空间
  char m_symbol[4];                 // bid/ask标识	1：bid,	-1：ofr
  char m_price[12];                 // 价格
  char m_priceDescription[96 + 1];  // 价格描述
  char m_netPrice[12];              //
  char m_fullPrice[12];             //
  char m_yield[12];                 // 收益率
  int m_quoteType;                  // 报价类型，转价格类型
  char m_volume[64];                // 有可能出现"40234+3212"的情况、
  OriginalQuoteInfo() { memset(this, 0, sizeof(OriginalQuoteInfo)); }
};

struct xQBOriginalQuoteRsponse_t {
  std::list<OriginalQuoteInfo> m_List;
};
//--------------------------------------------------------------------------------------------------
// E_FID_ORIGINAL_QUOTE_PUSH						= 61051,
// //基本报价推送
typedef xQBOriginalQuoteRsponse_t xQBOriginalQuotePush_t;
//-------------------------------------------------------------------------------------
// E_FID_ORIGINAL_QUOTE_HISTORY_REQ				= 61053,
// //请求基本报价历史
typedef xQBOriginalQuoteRequest_t xQBOriginalQuoteHistoryRequest_t;

struct OriginalQuoteHistoryInfo {
  char m_company_id[4];             // 经纪公司ID',
  char m_bondkey[32 + 1];           // 产品ID',
  char m_listedmarket[8];           // 市场代码
  char m_id[32 + 1];                // id
  char m_createTime[30];            // 创建时间
  char m_modifyTime[30];            // 修改时间
  char m_dealStatus[2];             // 交易状态
  char m_rateType[32 + 1];          // 利率方式
  char m_flagBargain[8];            // 议价空间
  char m_symbol[4];                 // bid/ask标识	1：bid,	-1：ofr
  char m_price[12];                 // 价格
  char m_priceDescription[96 + 1];  // 价格描述
  char m_netPrice[12];              //
  char m_fullPrice[12];             //
  char m_yield[12];                 // 收益率
  int m_quoteType;                  // 报价类型，转价格类型
  char m_volume[64];                // 有可能出现"40234+3212"的情况、
  char m_status[2];                 // 状态， 不为1都为删除
  char m_internally[2];             // 是否是内部报价，2为内部报价
  OriginalQuoteHistoryInfo() {
    memset(this, 0, sizeof(OriginalQuoteHistoryInfo));
  }
};

struct xQBOriginalQuoteHistoryAck_t {
  std::list<OriginalQuoteHistoryInfo> m_List;
};
//-------------------------------------------------------------------------------------
// E_FID_BBO_HISTORY_REQ
// = 61054,			//请求最优报价历史
typedef xQBOriginalQuoteRequest_t xQBBBOHistoryRequest_t;

struct xBBOHistoryInfo_t {
  char m_company_id[4];       // 经纪公司ID',
  char m_bondkey[32 + 1];     // 产品ID',
  char m_listedmarket[8];     // 市场代码
  char m_id[32 + 1];          // id
  char m_createTime[30];      // 创建时间
  char m_modifyTime[30];      // 修改时间
  char m_time[30];            // 修改时间
  char m_bidOfferId[32 + 1];  // bidOfferId
  char m_bidprice[12];        // 收益率
  char m_bid_cleanprice[12];  // 净价
  char m_bid_yield[12];       // 收益率
  char m_bidvolume[64];       // 有可能出现"40234+3212"的情况、
  char m_ofrOfferId[32 + 1];  // ofrOfferId
  char m_ofrprice[12];        // 收益率
  char m_ofr_cleanprice[12];  // 净价
  char m_ofr_yield[12];       // 收益率
  char m_ofrvolume[64];       // 有可能出现"40234+3212"的情况、

  char m_bidRebate[4];  // 是否返点(0-不返，1返点)
  char m_bidReturn_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  char m_ofrRebate[4];
  char m_ofrReturn_point[12];
  char m_bidflag_bargain[8];   // bid 可议价*',
  char m_bidflag_relation[8];  // bid OCO',
  char m_ofrflag_bargain[8];   // ofr 可议价*',
  char m_ofrflag_relation[8];  // ofr OCO',
  char m_bidExercise[2];       // 行权到期  (0-行权 1-到期)
  char m_ofrExercise[2];       // 行权到期  (0-行权 1-到期)

  char m_bid_description[128];  // 价格备注：如明天+1',
  char m_ofr_description[128];  // 价格备注：如明天+1',
  char m_tkn_price[32];         ////成交
  char m_indicate[32];          // 参考价
  char m_price_status[8];       // 价格状态
  char m_deal_status[8];        // 交易状态
  char m_symbol[4];             // bid/ask标识	1：bid,	-1：ofr
  int m_quoteType;              // 报价类型，转价格类型
  xBBOHistoryInfo_t() { memset(this, 0, sizeof(xBBOHistoryInfo_t)); }
};

struct xQBBBOHistoryAck_t {
  std::list<xBBOHistoryInfo_t> m_List;
};
//-------------------------------------------------------------------------------------
// E_FID_DEAL_HISTORY_REQ
// = 61055,			//请求成交历史
typedef xQBOriginalQuoteRequest_t xQBDealHistoryRequest_t;

struct xDealHistoryInfo_t {
  char m_company_id[4];    // 经纪公司ID',
  char m_bondkey[32 + 1];  // 产品ID',
  char m_listedmarket[8];  // 市场代码
  char m_id[32 + 1];       // id
  char m_createTime[30];   // 创建时间
  char m_modifyTime[30];   // 修改时间
  char m_price[12];        // 收益率
  char m_volume[64];       // 有可能出现"40234+3212"的情况、
  char m_fullPrice[12];    //
  char m_cleanPrice[12];   //
  char m_yield[12];        // 收益率
  char m_rebate[4];        // 是否返点(0-不返，1返点)
  char m_return_point
      [12];  // 返点值(例:
             // F0.10),值可以是0.0,也可以是空，代表不同的含义,空代表"全返",要注意区分
  char m_dealStatus[2];  //"0 ~ 3: 客户端显示成交，		4 ~ 6:
                         //客户端删除成交"
  char m_operate[5];     // 0 tkn, 1 gvn, 2 trd
  xDealHistoryInfo_t() { memset(this, 0, sizeof(xDealHistoryInfo_t)); }
};

struct xQBDealHistoryAck_t {
  std::list<xDealHistoryInfo_t> m_List;
};
//-------------------------------------------------------------------------------------
// E_FID_TF_ONE_MINUTE_HISTORY_REQ					= 61068,
// //国债期货一分钟历史
struct xQBTfOneMinuteHistoryReq_t {
  char m_ID[20];  // 合约号
  int m_Type;  // 0表示按月查询，1表示按开始时间和结束时间查询，
  time_t m_Month;      // 月份
  time_t m_starttime;  // 开始时间
  time_t m_endtime;    // 结束时间，
  xQBTfOneMinuteHistoryReq_t() {
    memset(this, 0, sizeof(xQBTfOneMinuteHistoryReq_t));
  }
};

struct xTfHistoryInfo_t {
  char m_ID[20];        // 合约号
  char m_Time[40];      // 时间
  char m_Price[12];     // 价格
  char m_Vol[64];       // 成交量
  char m_Position[20];  // 持仓量
  xTfHistoryInfo_t() { memset(this, 0, sizeof(xTfHistoryInfo_t)); }
};

struct xQBTfOneMinuteHistoryAck_t {
  std::vector<xTfHistoryInfo_t> m_List;
};
//-------------------------------------------------------------------------------------
// E_FID_TF_FIVE_MINUTE_HISTORY_REQ				= 61069,
// //国债期货五分钟历史
typedef xQBTfOneMinuteHistoryReq_t xQBTfFiveMinuteHistoryReq_t;
typedef xQBTfOneMinuteHistoryAck_t xQBTfFiveMinuteHistoryAck_t;

// E_FID_QB_SEND_EVENT_LOG_REQ = 50699,
// //上传EventLog，埋点，5.0版本 请求
class xQBEventLog_c {
 public:
  char m_FuncCode[64];  // 功能点编码
  time_t m_EventTime;   // 点击日期时间
  std::string m_Param;  // 功能点参数值,json格式字符串

  xQBEventLog_c() { clear(); }
  void clear() {
    m_EventTime = 0;
    _InitializeString(m_FuncCode);
    m_Param.clear();
  }
};

class xQBEventLogReq_c {
 public:
  char m_UserId[33];
  time_t m_UploadTime;  // 客户端上传日期时间
  std::list<xQBEventLog_c> m_list;
  xQBEventLogReq_c() { clear(); };
  void clear() {
    m_UploadTime = 0;
    _InitializeString(m_UserId);
    m_list.clear();
  }
};
// 应答包体为空，通过errcode判定是否成功

// E_FID_QB_SERVICE_PLATFORM_REQ = 50701,			//森浦服务平台
// 请求
class xQBServicePlatform_c {
 public:
  char m_UserId[33];
  char m_Mobile[16];         // 手机
  char m_Tel[16];            // 座机
  char m_CallBack_Time[16];  // 回访时间	eg. 13:00-13:30
  int m_CallBack_Date;       // 回访日期

  char m_QBVersion[16];   // QB版本
  char m_OSVersion[64];   // 操作系统版本
  char m_Resolution[16];  // qeubee主窗口所在屏幕分辨率
  float m_Dpi;            // qeubee主窗口所在屏幕DPI

  char m_Report_From[4];  // 消息来源，对于QB客户端始终为1

  std::string m_Content;  // 备注

  xQBServicePlatform_c() {
    _InitializeString(m_UserId);
    _InitializeString(m_Mobile);         // 手机
    _InitializeString(m_Tel);            // 座机
    _InitializeString(m_CallBack_Time);  // 回访时间	eg. 13:00-13:30
    m_CallBack_Date = 0;                 // 回访日期

    _InitializeString(m_QBVersion);   // QB版本
    _InitializeString(m_OSVersion);   // 操作系统版本
    _InitializeString(m_Resolution);  // qeubee主窗口所在屏幕分辨率
    m_Dpi = 0.f;                      // qeubee主窗口所在屏幕DPI
  }
};
// 应答包体为空，通过errcode判定是否成功 2021-5-13加入返回包
// 提示客户输入错误或者重复提交
class xQBServicePlatformAck_c {
 public:
  std::string m_ErrorString;  // 具体的错误
};

// E_FID_QB_SERVICE_PLATFORM_MANAGER_REQ = 50702,
// //森浦服务平台-客户经理 请求
class xQBServicePlatformManagerReq_c {
 public:
  xQBServicePlatformManagerReq_c() { _InitializeString(m_UserId); }
  char m_UserId[33];     // 用户ID
  char m_CompanyId[33];  // 用户所在机构ID
};

// 应答
class xQBServicePlatformManagerAck_c {
 public:
  xQBServicePlatformManagerAck_c() {
    _InitializeString(m_ManagerName);
    _InitializeString(m_PhoneNumber);
    _InitializeString(m_Email);
  }
  char m_ManagerName[16];  // 经理姓名
  char m_PhoneNumber[16];  // 联系号码
  char m_Email[128];       // 邮箱
};

// E_FID_QB_HIS_MARKETSTREAM_BOND = 50800, //请求某一天的历史成交债券信息
class xQBHisMarketstreamBond_Req_t {
 public:
  xQBHisMarketstreamBond_Req_t() : m_HisDate(0) {}
  int m_HisDate;                         //
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
};

class xQBHisMarketstreamBondUnit_c {
 public:
  char m_bondkey[32 + 1];      // bondkey
  char m_listedmarket[8];      // 市场代码
  char m_issuerRating[6];      // 主体评级
  char m_issuerBondRating[6];  // 债项评级

  char m_PreClose[32];    // 昨收
  float m_advYeild;       // 今日平均 5家broker
  float m_advYesYeild;    // 昨日平均 5家broker
  float m_cdcValuation;   // 中债估值
  float m_zzValuation;    // 中证估值
  float m_amount;         // 债券余额
  char m_cdcExercise[2];  // 中债估值行权到期  (0-行权 1-到期)
  char m_zzExercise[2];   // 中证估值行权到期  (0-行权 1-到期)

  float m_cdcValuationExtra;  // 中债估值, 含权债需要给到
                              // 另外一类中债估值，没有则不需给到对应字段
  char
      m_cdcExerciseExtra[2];  // 中债估值行权到期  (0-行权 1-到期)含权债需要给到
                              // 另外一类中债估值类型，没有则不需给到对应字段

  float m_zzValuationExtra;  // 中证估值, 含权债需要给到
                             // 另外一类中证估值，没有则不需给到对应字段
  char m_zzExerciseExtra[2];  // 中证估值行权到期  (0-行权 1-到期)含权债需要给到
                              // 另外一类中证估值类型，没有则不需给到对应字段

  // QB5.0 新增
  float m_cdcValuationClean;  // 中债估值净价，注意要和m_cdcExercise字段对应上
  float m_cdcValuationExtraClean;  // 中债估值净价, 含权债需要给到
                                   // 另外一类中债估值，没有则不需给到对应字段
  char m_PreCloseYield[32];  // 昨收收益率
  char m_PreCloseClean[32];  // 昨收净价
  char m_withinPeriodDeal
      [2];  // 是否属于20个工作日内有成交的券，'Y'为'是，''或者'N'为'否'；不足20个工作日的券不算入其中
  char m_listedFirstDeal
      [2];  // 是否属于上市后有成交的券，'Y'为'是，''或者'N'为'否'
  int m_Redemption_No;    // 还本方式,是否属于提前还本付息的券
  char m_OptionType[8];   // 含权类型 "ETS"
  char m_liquidLevel[4];  // 流动性，ABCD，
  char m_liquid[16];      // 流动性，百分比

  char m_sCDCRating[12];         // 中债隐含评级
  char m_sCSIRating[12];         // 中证隐含评级
  char m_sCBRRating[12];         // 中债资信评级
  char m_sCSIDefaultRating[12];  // 中证隐含违约率

  char m_sCouponRate[12];  // 票面利息

  xQBHisMarketstreamBondUnit_c() {
    m_advYeild = 0.0f;
    m_advYesYeild = 0.0f;
    m_cdcValuation = 0.0f;
    m_zzValuation = 0.0f;
    m_amount = 0.0f;  // 债券
    m_cdcValuationExtra = 0.0;
    m_zzValuationExtra = 0.0;
  }
};

class xQBHisMarketstreamBond_Ack_c {
 public:
  xQBHisMarketstreamBond_Ack_c() : m_HisDate(0) {}
  int m_HisDate;                                   //
  std::list<xQBHisMarketstreamBondUnit_c> m_List;  // 债券信息
};

// E_FID_QB_HIS_MARKETSTREAM_DEAL = 50801,
// //请求某一天的历史成交信息
class xQBHisMarketstreamDeal_Req_t {
 public:
  xQBHisMarketstreamDeal_Req_t() : m_HisDate(0) {}
  int m_HisDate;                         //
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司列表数据
};

class xQBHisMarketstreamDealUnit_c {
 public:
  char m_bondkey[32 + 1];   // bondkey
  char m_listedmarket[8];   // 市场代码
  char m_exercise[2];       // 行权到期  (0-行权 1-到期)
  char m_BrokerID[32 + 1];  // BrokerID,
  char m_quotetype[4];  // 报价类型，0-有意向；1-净价；2-全价；3-收益率；4-利差
  int m_type;          // 成交方向
  float m_price;       // 成交价格
  float m_duration;    // 久期
  time_t m_dealTime;   // 成交时间
  float m_yield;       // 收益率
  float m_cleanPrice;  // 净价
  // QB5.0 新增
  char m_dealStatus[2];  //"0 ~ 3: 客户端显示成交，
  // 核对下成交收益率和净价计算是否和全景统计一致
  xQBHisMarketstreamDealUnit_c() {
    m_type = 0;
    m_price = 0.0f;
    m_duration = 0.0f;
    m_dealTime = 0;
    m_yield = 0.0f;
    m_cleanPrice = 0.0f;
  }
};

class xQBHisMarketstreamDeal_Ack_c {
 public:
  xQBHisMarketstreamDeal_Ack_c() : m_HisDate(0) {}
  int m_HisDate;                                   //
  std::list<xQBHisMarketstreamDealUnit_c> m_List;  // 报价信息
};

// E_FID_QB_BOND_ATTENTION_DEL_PUSH			= 50561,
// //推送--债券取消关注 无需注册 应答
typedef struct xQBAttentionDelNotify_t {
  char m_UserId[32 + 1];   // 用户id
  char m_GroupId[32 + 1];  // 分类id
  char m_AttentionId[80];  // 关注id
  xQBAttentionDelNotify_t() {
    memset(this, 0, sizeof(xQBAttentionDelNotify_t));
  };
} QBAttentionDelNotify_t, *PQBAttentionDelNotify_t;

//--------------------------------------------------------------------------------------------------
// E_FID_INTEREST_RATES_SWAP_TICK_REQ				= 61093,
// //请求利率互换tick快照
struct xQBIrsTickReqItem {
  char m_Code[32];  // 代码
  char m_Type[32];  // 类型
  char m_Term[16];  // 期限

  xQBIrsTickReqItem() { memset(this, 0, sizeof(xQBIrsTickReqItem)); }
};

struct xQBIrsTickReq_t {
  std::list<xQBIrsTickReqItem> m_List;
};

struct xQBIrsAckItem {
  char m_Code[32];       // 代码
  char m_Type[32];       // 类型
  char m_Term[16];       // 期限
  time_t m_UpdateTime;   // 更新时间
  char m_Mid[16];        // 中间价
  char m_Bid[16];        // 买入价
  char m_Ofr[16];        // 卖出价
  char m_High[16];       // 最高价
  char m_Low[16];        // 最低价
  char m_Open[16];       // 开盘价
  char m_LastClose[16];  // 昨收
  int m_BidStatus;       // 买入价状态
  int m_OfrStatus;       // 卖出价状态
  xQBIrsAckItem() { memset(this, 0, sizeof(xQBIrsAckItem)); }
};

struct xQBIrsTickAck_t {
  std::list<xQBIrsAckItem> m_List;
};
//--------------------------------------------------------------------------------------------------
// E_FID_INTEREST_RATES_SWAP_TICK_TODAY_HISTORY_REQ= 61094,
// //请求利率互换tick当日历史
typedef xQBIrsTickReq_t xQBIrsTickTodayHistoryReq_t;
typedef xQBIrsTickAck_t xQBIrsTickTodayHistoryAck_t;
//--------------------------------------------------------------------------------------------------
// E_FID_INTEREST_RATES_SWAP_TICK_PUSH				= 61095,
// //利率互换tick推送
typedef xQBIrsTickAck_t xQBIrsTickPush_t;

//--------------------------------------------------------------------------------------------------
// E_FID_INTEREST_RATES_SWAP_DAY_LINE_REQ			= 61098,
// //请求利率互换日线

struct xQBIrsDayLineReqItem {
  char m_Code[32];  // 代码
  char m_Type[32];  // 类型
  char m_Term[16];  // 期限
  time_t m_Month;   // 取年月,按月查询

  xQBIrsDayLineReqItem() { memset(this, 0, sizeof(xQBIrsDayLineReqItem)); }
};

struct xQBIrsDayLineReq_t {
  std::list<xQBIrsDayLineReqItem> m_List;
};

struct xQBIrsDayLineAckItem {
  char m_Code[32];       // 代码
  char m_Type[32];       // 类型
  char m_Term[16];       // 期限
  time_t m_UpdateTime;   // 更新时间
  char m_Mid[16];        // 中间价
  char m_High[16];       // 最高价
  char m_Low[16];        // 最低价
  char m_Open[16];       // 开盘价
  char m_LastClose[16];  // 昨收
  xQBIrsDayLineAckItem() { memset(this, 0, sizeof(xQBIrsDayLineAckItem)); }
};

struct xQBIrsDayLineAck_t {
  std::list<xQBIrsDayLineAckItem> m_List;
};

// E_FID_QB_DEBUG_REPORT = 51798,			//
// 客户端检测调试寄存器异常，上报服务器
struct xQBDebugerReport {
  char m_disc[128];    // 描述
  char m_version[33];  // 客户端版本
  xQBDebugerReport() { memset(this, 0, sizeof(xQBDebugerReport)); }
};

// E_FID_QB_QUOTE_RESET = 51997,			// broker行情重置

struct xQBQuoteReset_t {
  char m_BrokerID[32 + 1];  // BrokerID,
  int m_Signal;             // 信号，1=Clear，2=Reset，其他=无效
  xQBQuoteReset_t() { memset(this, 0, sizeof(xQBQuoteReset_t)); }
};

// 透传消息结构体数据
struct xQBRawData {
  std::string m_Type;    // 类型
  std::string m_Buffer;  // 内容
};

//---------------------------------------------------------------------------------
// 报价板方案基础数据
struct xQBQuoteWndPosInfo {
  int m_type;  // 窗口类型，0表示行情小窗，1表示利差小窗
  char m_com_bond_code[64];       // 债券comcode
  char m_com_bond_code_next[64];  // 债券comcode
  int m_x_pos;                    // x坐标
  int m_y_pos;                    // y坐标
  int m_width;                    // 窗口宽度
  int m_height;                   // 窗口高度
  int m_is_lock;  // 是否置顶， 0表示不置顶， 1表示置顶
  xQBQuoteWndPosInfo()
      : m_type(0),
        m_x_pos(0),
        m_y_pos(0),
        m_width(0),
        m_height(0),
        m_is_lock(0) {
    _InitializeString(m_com_bond_code);
    _InitializeString(m_com_bond_code_next);
  }
  xQBQuoteWndPosInfo& operator=(const xQBQuoteWndPosInfo& outer) {
    if (this == &outer) return *this;
    m_type = outer.m_type;
    __FIELDCOPY__(m_com_bond_code, outer.m_com_bond_code);
    __FIELDCOPY__(m_com_bond_code_next, outer.m_com_bond_code_next);
    m_x_pos = outer.m_x_pos;
    m_y_pos = outer.m_y_pos;
    m_width = outer.m_width;
    m_height = outer.m_height;
    m_is_lock = outer.m_is_lock;
    return *this;
  }
  int SetLock(bool bAlwaysOnTop) {
    if (bAlwaysOnTop) {
      m_is_lock = 1;
    } else {
      m_is_lock = 0;
    }
    return m_is_lock;
  }
  bool GetLock() const {
    if (m_is_lock == 1) return true;
    return false;
  }
};
struct xQBQuoteFilterSchemeUnit {
  char m_scheme_id[32 + 1];  // 方案id
  char m_scheme_name[16];    // 方案名称，判断方案的标识
  int m_update_time;         // 方案更新时间
  int m_rank;  // 方案排序，如果有删除，大于该方案m_rank的方案的m_rank做自减处理
  std::list<xQBQuoteWndPosInfo>
      m_list_wnd_pos_info;  // 窗口布局list,最多可能有30个

  xQBQuoteFilterSchemeUnit() : m_update_time(0), m_rank(0) {
    _InitializeString(m_scheme_id);
    _InitializeString(m_scheme_name);
  }
  bool operator<(const xQBQuoteFilterSchemeUnit& other) {
    return m_rank < other.m_rank;
  }
  xQBQuoteFilterSchemeUnit& operator=(const xQBQuoteFilterSchemeUnit& outer) {
    if (this == &outer) return *this;
    __FIELDCOPY__(m_scheme_id, outer.m_scheme_id);
    __FIELDCOPY__(m_scheme_name, outer.m_scheme_name);
    m_update_time = outer.m_update_time;
    m_rank = outer.m_rank;
    m_list_wnd_pos_info = outer.m_list_wnd_pos_info;
    return *this;
  }
  bool operator==(const xQBQuoteFilterSchemeUnit& outer) {
    return strcmp(m_scheme_name, outer.m_scheme_name) == 0;
  }
};

//------------------------------------------------------------------------------------
// E_FID_QB_QUOTE_BOARD_SCHEME_QRY = 52600,
// 报价板方案及布局内容查询

struct xQBQuoteBoardSchemeQryReq {
  char m_user_id[32 + 1];  // 用户id
  xQBQuoteBoardSchemeQryReq() { _InitializeString(m_user_id); }
};

struct xQBQuoteBoardSchemeQryAck {
  std::list<xQBQuoteFilterSchemeUnit> m_list_scheme;  // 含每个方案的布局内容
};

//---------------------------------------------------------------------------------
// E_FID_QB_QUOTE_BOARD_SCHEME_MDF   = 52601,
// 报价板方案的增加，含布局内容
struct xQBQuoteBoardSchemeMdfReq {
  char m_user_id[32 + 1];  // 用户id
  int m_mdf_type;          // 0表示增加；1表示替换；2表示删除
  xQBQuoteFilterSchemeUnit
      m_scheme;  // 增加：不填写schemeid或者schemeid为空,但是会包含一系列的布局信息
                 // 替换：填写schemeid,
                 // 会替换scheme的m_update_time，以及布局信息m_list_wnd_pos_info
                 // 删除： 仅填写schemeid和schemename,
                 // 如果属于删除操作，大于本m_rank的方案m_rank均需要自减1
  xQBQuoteBoardSchemeMdfReq() {
    _InitializeString(m_user_id);
    m_mdf_type = 0;
  }
};

struct xQBQuoteBoardSchemeMdfAck {
  int m_mdf_type;  // 0表示增加；1表示替换；2表示删除；
                   // 将请求中附带的m_mdf_type返回
  xQBQuoteFilterSchemeUnit
      m_scheme;  // 增加：填写新增的schemeid和更新后的m_rank，
                 // 以及请求含的m_update_time|m_scheme_name|
                 // 窗口布局信息m_list_wnd_pos_info，客户端做完全替换
  // 替换：填写同增加应答的字段，客户端依照应答做完全替换
  // 删除： 填写schemeid和schemename和请求附带的m_rank,
  // 如果属于删除操作，服务端该用户大于本m_rank的方案m_rank均需要自减1，客户端也会做同样操作
  xQBQuoteBoardSchemeMdfAck() { m_mdf_type = -1; }
};

//--------------------------------------------------------------------------------
// E_FID_QB_QUOTE_BOARD_SEL_SCHEME_QRY   = 52602,
// 用户使用的方案名称
struct xQBQuoteBoardSelSchemeQryReq {
  char m_user_id[32 + 1];  // 用户id
  xQBQuoteBoardSelSchemeQryReq() { _InitializeString(m_user_id); }
};

struct xQBQuoteBoardSelSchemeQryAck {
  char m_scheme_name[16];  // 方案名称
  xQBQuoteBoardSelSchemeQryAck() { _InitializeString(m_scheme_name); }
};

//----------------------------------------------------------------------------------
// E_FID_QB_QUOTE_BOARD_SEL_SCHEME_MDF = 52603,
// 用户使用的方案名称修改
struct xQBQuoteBoardSelSchemeMdfReq {
  char m_user_id[32 + 1];  // 用户id
  char m_scheme_name[16];  // 方案名称
  xQBQuoteBoardSelSchemeMdfReq() {
    _InitializeString(m_user_id);
    _InitializeString(m_scheme_name);
  }
};

typedef xQBQuoteBoardSelSchemeQryAck xQBQuoteBoardSelSchemeMdyAck;

struct xQBTFStatisticsMemberUnit {
  char m_mem_key[64];  // 会员key
  char m_mem_name[128];  // 会员name,可能出现过长情况，建议使用key存储
  xQBTFStatisticsMemberUnit() {
    _InitializeString(m_mem_key);
    _InitializeString(m_mem_name);
  }
};

//------------------------------------------------------------------------------------
// E_FID_QB_TF_STATISTICS_SCHEME_QRY				= 52700,
// //TF保存方案查询

struct xQBTFStatisticsSchemeQry {
  char m_user_id[32 + 1];  // 用户id
  xQBTFStatisticsSchemeQry() { _InitializeString(m_user_id); }
};

struct xQBTFStatisticsSchemeQryAck {
  char m_category_tf_type[64];  // 选中的期货大类
  char m_sub_tf_type[64];       // 大类下小分类，含连续合约
  std::list<xQBTFStatisticsMemberUnit> m_list_member_info;
  xQBTFStatisticsSchemeQryAck() {
    _InitializeString(m_category_tf_type);
    _InitializeString(m_sub_tf_type);
  }
};

//---------------------------------------------------------------------------------
// E_FID_QB_TF_STATISTICS_SCHEME_MDF = 52701, //TF保存方案修改,
// 应答给到同样内容，用以前后端同步
struct xQBTFStatisticsSchemeMdyReq {
  char m_user_id[32 + 1];  // 用户id
  xQBTFStatisticsSchemeQryAck
      m_scheme;  // 方案做全部替换，每次请求给到用户全部方案
  xQBTFStatisticsSchemeMdyReq() { _InitializeString(m_user_id); }
};

typedef xQBTFStatisticsSchemeQryAck xQBTFStatisticsSchemeMdyAck;

//---------------------------------------------------------------------------------
// E_FID_QB_TF_SETTLEMENT_OVERALL_QRY = 52702,
// //TF交割统计历史价格数据, 当日请求，给当日的统计
struct xQBTFSettlementOverAllQry {
  char m_category_tf_type[64];  // 选中的期货大类
  xQBTFSettlementOverAllQry() { _InitializeString(m_category_tf_type); }
};

struct xQBTFSettlementOverAllQryAckUnit {
  char m_tf_id[20];              // 合约代码
  char m_delivery_volume[64];    // 交割量
  char m_settlement_amount[64];  // 交割金额(万元)
  xQBTFSettlementOverAllQryAckUnit() {
    _InitializeString(m_tf_id);
    _InitializeString(m_delivery_volume);
    _InitializeString(m_settlement_amount);
  }
  void SplitTF(std::string sTFId, int& nType, int& nDate) {
    nType = 0;
    if (sTFId.find("TF") != sTFId.npos) {
      nType = 1;
    } else if (sTFId.find("TS") != sTFId.npos) {
      nType = 2;
    }
    if (nType == 0) {
      nDate = atoi(sTFId.substr(1).c_str());
    } else {
      nDate = atoi(sTFId.substr(2).c_str());
    }
  }
  bool operator<(const xQBTFSettlementOverAllQryAckUnit& other) {
    int nTypeLeft{0}, nDateLeft{0}, nTypeRight{0}, nDateRight{0};
    SplitTF(m_tf_id, nTypeLeft, nDateLeft);
    SplitTF(other.m_tf_id, nTypeRight, nDateRight);
    if (nDateLeft == nDateRight) return nTypeLeft < nTypeRight;
    return nDateLeft > nDateRight;
  }
};
struct xQBTFSettlementOverAllQryAck {
  std::list<xQBTFSettlementOverAllQryAckUnit> m_list;  // 交割总览
};

//--------------------------------------------------------------------------------------------------
//	E_FID_QB_TF_SETTLEMENT_DETAIL_QRY				= 52703,
////TF交割统计交割明细

struct xQBTFSettlementDetailQry {
  char m_tf_id[20];  // tf id
  xQBTFSettlementDetailQry() { _InitializeString(m_tf_id); }
};

struct xQBTFSettlementDetailTfUnit {
  char m_date[20];               // 意向申报日期,格式例如2019-12-16
  char m_delivery_volume[64];    // 交割量
  char m_settlement_amount[64];  // 交割金额(万元)
  bool m_bAll;
  xQBTFSettlementDetailTfUnit() {
    _InitializeString(m_date);
    _InitializeString(m_delivery_volume);
    _InitializeString(m_settlement_amount);
    m_bAll = false;
  }
  bool operator<(const xQBTFSettlementDetailTfUnit& other) {
    return strcmp(m_date, other.m_date) < 0;
  }
};
struct xQBTFSettlementDetailBondUnit {
  char m_bond_name[256];         // 债券全称
  char m_bond_code[64];          // 交割国债代码
  char m_delivery_volume[64];    // 交割量
  char m_settlement_amount[64];  // 交割金额
  char m_maturity_date[15];      // 过期日
  bool m_bAll;
  xQBTFSettlementDetailBondUnit() {
    _InitializeString(m_bond_name);
    _InitializeString(m_bond_code);
    _InitializeString(m_delivery_volume);
    _InitializeString(m_settlement_amount);
    _InitializeString(m_maturity_date);
    m_bAll = false;
  }
};

struct xQBTFSettlementDetailQryAck {
  char m_tf_id[20];  // tf id
  std::list<xQBTFSettlementDetailTfUnit> m_list_tf;
  std::list<xQBTFSettlementDetailBondUnit> m_list_bond;
  xQBTFSettlementDetailQryAck() { _InitializeString(m_tf_id); }
};

//--------------------------------------------------------------------------------------------------
// E_FID_QB_TF_SETTLEMENT_REPORT_TF_QRY = 52704,
// //TF交割统计交割报告查询,期货
struct xQBTFSettlementReportTFQry {
  char m_tf_id[20];  // tf id
  xQBTFSettlementReportTFQry() { _InitializeString(m_tf_id); }
};
struct xQBTFSettlementReportTFQryAckUnit {
  char m_date[20];     // 意向申报日期，格式例如2019-12-16
  char m_mem_key[64];  // 会员key
  char m_mem_name[128];  // 会员name,可能出现过长情况，建议使用key存储;
                         // 注意这里含有非会员；都要给到
  char m_delivery_volume_bid[64];  // 交割量 买方
  char m_delivery_volume_ofr[64];  // 交割量_卖方
  xQBTFSettlementReportTFQryAckUnit() {
    _InitializeString(m_date);
    _InitializeString(m_mem_key);
    _InitializeString(m_mem_name);
    _InitializeString(m_delivery_volume_bid);
    _InitializeString(m_delivery_volume_ofr);
  }
  bool operator<(const xQBTFSettlementReportTFQryAckUnit& unit) {
    return strcmp(m_date, unit.m_date) < 0;
  }
};

struct xQBTFSettlementReportTFQryAck {
  char m_tf_id[20];  // tf id
  std::list<xQBTFSettlementReportTFQryAckUnit>
      m_list;  // 按照日期大类统计，前端计算合计值
  xQBTFSettlementReportTFQryAck() { _InitializeString(m_tf_id); }
};
//--------------------------------------------------------------------------------------------------
// E_FID_QB_TF_SETTLEMENT_REPORT_BOND_QRY			= 52705,
// //TF交割统计交割报告查询,国债
struct xQBTFSettlementReportBondQry {
  char m_tf_id[20];  // tf id
  xQBTFSettlementReportBondQry() { _InitializeString(m_tf_id); }
};
struct xQBTFSettlementReportBondQryAckUnit {
  char m_date[20];               // 意向申报日期，格式例如2019-12-16
  char m_delivery_volume[64];    // 申报交割量
  char m_settlement_amount[64];  // 交割金额
  char m_bond_name[256];         // 债券全称
  char m_bond_code[64];          // 交割国债代码
  char m_maturity_date[15];      // 到期日
  char m_rate[12];               // 票面利率
  char m_converter[12];          // 转换因子
  xQBTFSettlementReportBondQryAckUnit() {
    _InitializeString(m_date);
    _InitializeString(m_delivery_volume);
    _InitializeString(m_settlement_amount);
    _InitializeString(m_bond_name);
    _InitializeString(m_bond_code);
    _InitializeString(m_maturity_date);
    _InitializeString(m_rate);
    _InitializeString(m_converter);
  }
  bool operator<(const xQBTFSettlementReportBondQryAckUnit& other) {
    if (strcmp(m_date, other.m_date) == 0) {
      return strcmp(m_maturity_date, other.m_maturity_date) < 0;
    }
    return strcmp(m_date, other.m_date) < 0;
  }
};

struct xQBTFSettlementReportBondQryAck {
  char m_tf_id[20];  // tf id
  std::list<xQBTFSettlementReportBondQryAckUnit>
      m_list;  // 按照日期大类统计，前端计算合计值
  xQBTFSettlementReportBondQryAck() { _InitializeString(m_tf_id); }
};
//--------------------------------------------------------------------------------------------------
//	E_FID_QB_TF_MAIN_RANK_OVERALL_QRY				= 52706,
////TF主力成交持仓排名市场总览,根据日期查询
struct xQBTFMainRankOverAllQry {
  char m_date[20];   // 查询报告日期，格式例如2019-12-16
  char m_tf_id[20];  // tf id
  xQBTFMainRankOverAllQry() {
    _InitializeString(m_date);
    _InitializeString(m_tf_id);
  }
};

struct xQBTFMainRankOverAllQryAckUnit {
  char m_mem_key[64];  // 会员key
  char m_mem_name
      [128];  // 会员name,前五，前十，前二十，期货公司，非期货公司，全市场
  char m_amount_deal[64];      // 量 成交排行
  char m_change_deal[64];      // 增减 成交排行
  char m_proportion_deal[64];  // 占比 成交排行
  char m_amount_bull[64];      // 量 多头持仓
  char m_change_bull[64];      // 增减 多头持仓
  char m_proportion_bull[64];  // 占比 多头持仓
  char m_amount_bear[64];      // 量 空头持仓
  char m_change_bear[64];      // 增减 空头持仓
  char m_proportion_bear[64];  // 占比 空头持仓
  char m_amount_bull_net[64];  // 净多单 净持仓
  char m_change_bull_net[64];  // 增减（净多单） 净持仓
  char m_amount_bear_net[64];  // 净空单 净持仓
  char m_change_bear_net[64];  // 增减（净空单）净持仓
  xQBTFMainRankOverAllQryAckUnit() {
    _InitializeString(m_mem_key);
    _InitializeString(m_mem_name);
    _InitializeString(m_amount_deal);      // 量 成交排行
    _InitializeString(m_change_deal);      // 增减 成交排行
    _InitializeString(m_proportion_deal);  // 占比 成交排行
    _InitializeString(m_amount_bull);      // 量 多头持仓
    _InitializeString(m_change_bull);      // 增减 多头持仓
    _InitializeString(m_proportion_bull);  // 占比 多头持仓
    _InitializeString(m_amount_bear);      // 量 空头持仓
    _InitializeString(m_change_bear);      // 增减 空头持仓
    _InitializeString(m_proportion_bear);  // 占比 空头持仓
    _InitializeString(m_amount_bull_net);  // 净多单 净持仓
    _InitializeString(m_change_bull_net);  // 增减（净多单） 净持仓
    _InitializeString(m_amount_bear_net);  // 净空单 净持仓
    _InitializeString(m_change_bear_net);  // 增减（净空单）净持仓
  }
};

struct xQBTFMainRankOverAllQryAck {
  std::list<xQBTFMainRankOverAllQryAckUnit>
      m_rank;  // 会员name,前五，前十，前二十，期货公司，非期货公司，全市场
};
//--------------------------------------------------------------------------------------------------
// E_FID_QB_TF_MAIN_RANK_COMPO_RANK_QRY = 52707,
// //TF主力成交持仓排名_当期综合排名汇总（前20），根据日期查询
struct xQBTFMainRankCompoRankQry {
  char m_date[20];   // 查询报告日期，格式例如2019-12-16
  char m_tf_id[20];  // tf id
  xQBTFMainRankCompoRankQry() {
    _InitializeString(m_date);
    _InitializeString(m_tf_id);
  }
};

struct xQBTFMainRankCompoRankQryAckUnit {
  char m_mem_key[64];          // 会员key
  char m_mem_name[128];        // 会员name, 期货公司名称
  char m_rank_deal[12];        // 名次 成交
  char m_amount_deal[64];      // 量 成交
  char m_change_deal[64];      // 增减 成交
  char m_rank_bull[12];        // 名次 多头持仓
  char m_amount_bull[64];      // 量 多头持仓
  char m_change_bull[64];      // 增减 多头持仓
  char m_rank_bear[12];        // 名次 空头持仓
  char m_amount_bear[64];      // 量 空头持仓
  char m_change_bear[64];      // 增减 空头持仓
  char m_amount_bull_net[64];  // 净多单 净持仓
  char m_change_bull_net[64];  // 增减（净多单） 净持仓
  char m_amount_bear_net[64];  // 净空单 净持仓
  char m_change_bear_net[64];  // 增减（净空单）净持仓
  xQBTFMainRankCompoRankQryAckUnit() {
    _InitializeString(m_mem_key);
    _InitializeString(m_mem_name);
    _InitializeString(m_rank_deal);        // 名次 成交
    _InitializeString(m_amount_deal);      // 量 成交
    _InitializeString(m_change_deal);      // 增减 成交
    _InitializeString(m_rank_bull);        // 名次 多头持仓
    _InitializeString(m_amount_bull);      // 量 多头持仓
    _InitializeString(m_change_bull);      // 增减 多头持仓
    _InitializeString(m_rank_bear);        // 名次 空头持仓
    _InitializeString(m_amount_bear);      // 量 空头持仓
    _InitializeString(m_change_bear);      // 增减 空头持仓
    _InitializeString(m_amount_bull_net);  // 净多单 净持仓
    _InitializeString(m_change_bull_net);  // 增减（净多单） 净持仓
    _InitializeString(m_amount_bear_net);  // 净空单 净持仓
    _InitializeString(m_change_bear_net);  // 增减（净空单）净持仓
  }
};
struct xQBTFMainRankCompoRankQryAck {
  std::list<xQBTFMainRankCompoRankQryAckUnit> m_rank;  // 排行榜
};
//--------------------------------------------------------------------------------------------------
// E_FID_QB_TF_MAIN_RANK_CLASS_RANK_QRY = 52708,
// //TF主力成交持仓排名_主力成交持仓排名（前20），根据日期查询

struct xQBTFMainRankClassRankQry {
  char m_date[20];   // 查询报告日期，格式例如2019-12-16
  char m_tf_id[20];  // tf id
  xQBTFMainRankClassRankQry() {
    _InitializeString(m_date);
    _InitializeString(m_tf_id);
  }
};
struct xQBTFMainRankClassRankQryAckUnit {
  char m_mem_key[64];    // 会员key
  char m_mem_name[128];  // 会员name, 期货公司名称
  char m_rank[12];       // 名次
  char m_amount[64];     // 量
  char m_change[64];     // 增减
  xQBTFMainRankClassRankQryAckUnit() {
    _InitializeString(m_mem_key);
    _InitializeString(m_mem_name);
    _InitializeString(m_rank);
    _InitializeString(m_amount);
    _InitializeString(m_change);
  }
};

struct xQBTFMainRankClassRankQryAck {
  std::list<xQBTFMainRankClassRankQryAckUnit> m_deal;  // 成交量
  std::list<xQBTFMainRankClassRankQryAckUnit> m_bull;  // 多头持仓
  std::list<xQBTFMainRankClassRankQryAckUnit> m_bear;  // 空头持仓
};
//--------------------------------------------------------------------------------------------------
// E_FID_QB_TF_STATISTICS_FILTER_QRY = 52709,
// //TF统计_主力成交持仓统计查询，全数据
struct xQBTFStatisticsFilterQry {
  // begin_date
  int m_begin_date;  // 起始日期，格式：20200101

  // end_date
  int m_end_date;  // 结束日期，格式：20200131

  // tf_type
  //  合约类型，当期合约和过期合约。
  // 沿用之前国债期货请求50251之结果中的m_TF_ID(合约代码);
  char m_tf_type[64];

  typedef std::list<std::string> LIST_MEMBER;
  // List
  // 会员类型，内容为“全市场”、“每日前十”、“每日前二十”、“期货公司”的Key。
  // 全市场-mall;每日前10-mtop10;每日前20-mtop20;
  LIST_MEMBER m_list_member_info;

  xQBTFStatisticsFilterQry() {
    m_begin_date = 0;
    m_end_date = 0;
    memset(m_tf_type, 0, sizeof(m_tf_type));
    m_list_member_info.clear();
  }
};

struct xQBTFStatisticsFilterQryAckUnit {
  // mem_key
  char m_mem_key[64];  // 会员key
  // update_date
  int m_update_date;  // 报告日期，格式例如20191216
  // amount_deal
  char m_amount_deal[64];  // 成交量
  // proportion
  char m_proportion[64];  // 占比
  // amount_bull
  char m_amount_bull[64];  // 多头持仓
  // amount_bear
  char m_amount_bear[64];  // 空头持仓
  // amount_net
  char m_amount_net[64];  // 净持仓
};

struct xQBTFStatisticsFilterQryAck {
  // begin_date
  int m_begin_date;  // 起始日期，格式：20200101
  // end_date
  int m_end_date;  // 结束日期，格式：20200131
  // List
  std::list<xQBTFStatisticsFilterQryAckUnit>
      m_list;  // 根据分类下对应每个分类的列表；由前端计算并集并展示；每个分类下对应系列相关日期数据

  xQBTFStatisticsFilterQryAck() {
    m_begin_date = 0;
    m_end_date = 0;
    m_list.clear();
  }
};

//--------------------------------------------------------------------------------------------------
// E_FID_TF_SETTLEMENT_PRICE_REQ					= 61160,
// //请求所有国债期货历史结算价
struct xQBTfSettlementPriceReq {
  char m_Start[16];  // 开始时间 2016-10-29
  char m_End[16];    // 结束时间 2016-11-29

  xQBTfSettlementPriceReq() {
    memset(this, 0, sizeof(xQBTfSettlementPriceReq));
  }
};

struct xQBTfSettlementPriceAckItem {
  char m_Id[32];      // 期货ID
  char m_Time[16];    // 时间 2016-11-29
  float m_SettPrice;  // 结算价

  xQBTfSettlementPriceAckItem() {
    memset(this, 0, sizeof(xQBTfSettlementPriceAckItem));
  }
};

struct xQBTfSettlementPriceAck {
  std::list<xQBTfSettlementPriceAckItem> m_List;
};
//--------------------------------------------------------------------------------------------------
// E_FID_BOND_TYPE_CLEAN_PRICE_REQ					= 61161,
// //请求所有债券净价 国债，国开，农发， 口行，地方债
struct xQBBondTypePriceReq {
  char m_Start[16];  // 开始时间 2016-10-29
  char m_End[16];    // 结束时间 2016-11-29
  xQBBondTypePriceReq() { memset(this, 0, sizeof(xQBBondTypePriceReq)); }
};

struct xQBBondTypePriceAckItem {
  char m_Type[32];     // 国债，国开，农发， 口行，地方债
  char m_Maturity[8];  // 年限 Y1， Y3...
  int m_Active;        // 0-活跃，1-次活跃
  char m_Time[16];     // 时间 2016-11-29
  float m_CleanPrice;  // 净价

  xQBBondTypePriceAckItem() {
    memset(this, 0, sizeof(xQBBondTypePriceAckItem));
  }
};

struct xQBBondTypePriceAck {
  std::list<xQBBondTypePriceAckItem> m_List;
};

//--------------------------------------------------------------------------------------------------
// E_FID_BOND_KLINE = 61170,
// //请求债券的日K线，分经纪商，开盘为第一笔交易，收盘为最后一笔交易
struct xQBBondKLineRequest {
  std::list<xQBTradeCmpyInfo_c> m_List;  // 经纪公司id列表数据
  char m_bondkey[32 + 1];                // bondkey
  char m_listedmarket[8];                // 市场代码
  time_t m_starttime;                    // 开始时间。取年月日
  time_t m_endtime;  // 结束时间。-1表示结束时间无效

  xQBBondKLineRequest() : m_starttime(0), m_endtime(-1) {
    memset(m_bondkey, 0, sizeof(m_bondkey));
    memset(m_listedmarket, 0, sizeof(m_listedmarket));
  }
};

struct QBBondKLineInfo {
  char m_company_id[4];    // 经纪公司ID
  char m_bondkey[32 + 1];  // 产品ID
  char m_listedmarket[8];  // 市场代码
  float m_high;            // 最高价格
  float m_low;             // 最低价格
  float m_open;            // 开盘价格
  float m_close;           // 收盘价格
  int m_open_time;         // 开盘时间
  int m_close_time;        // 收盘时间
  int m_time;              // 日期
  int m_count;             // 成交笔数
  int m_volumn;            // 成交量

  QBBondKLineInfo() { memset(this, 0, sizeof(QBBondKLineInfo)); }
};

struct xQBBondKLineRsponse {
  std::list<QBBondKLineInfo> m_List;
};

// E_FID_QB_NOTICE_REQ = 50675,			//QB临时市场通知，交易警示请求
// E_FID_QB_NOTICE_PUSH = 50676,
// //QB临时市场通知，交易警示注册 请求
struct xQBNoticeReq_t {
  std::list<int> m_noticeType;  //[1,2]
};

// 应答
struct xQBNotice_t {
  enum {
    noticetype_none = 0,
    noticetype_tradewarn = 1,
    noticetype_marketannounce = 2,
    noticetype_max
  };
  int m_noticeType;           // 通知类型，1-交易警示， 2-市场通告
  int m_action;               // 行为，1-开启，2-关闭,
  int m_status;               // 状态，1-有效，2-删除,
  std::string m_noticeId;     // ID
  std::string m_iconStyle;    // icon类型,"warning","notice","error",...
  std::string m_noticeTitle;  // 标题
  std::string m_message;      // 显示内容主题，以'\n'换行
  std::string m_hyperlink;    // 点击之后的web页面链接
  std::string m_tips;         // 提示语
  std::string m_buttonStyle;  // 按钮类型,"ok","close","cancel","custom"
  std::string m_buttonText;   // 按钮文本，当buttonStyle==custom有效
  time_t m_startTime;         // 开始时间
  time_t m_expireTime;        // 过期时间
  int m_showTime;    //>0：多少秒后自动消失；<=0：不自动消失
  int m_showupFreq;  // 再次显示的频率；0：只显示一次；>0表示间隔多久自动显示

  xQBNotice_t()
      : m_action(0),
        m_status(0),
        m_noticeType(noticetype_none),
        m_startTime(0),
        m_expireTime(0),
        m_showTime(0),
        m_showupFreq(0){};
};

struct xQBNoticeAck_t {
  std::list<xQBNotice_t> m_list;
};

//--------------------------------------------------------------------------------------------------
// E_FID_PRI_QUTOE_TIPS_FANOUT = 55093,
// //一级分享报价状态变化提醒，推送
struct xPriQuoteTipsAck_c {
 public:
  // List
  std::list<std::string> xList;
};

/************************************************************************/
/* 首页   市场行情                                                        */
/************************************************************************/

// E_FID_QB_PAGE_EXCHANGE_REALTIME_REQ = 53040,   //交易所市场行情--请求
// E_FID_QB_PAGE_EXCHANGE_REALTIME_PUSH = 53041,   //交易所市场行情--推送
// E_FID_QB_PAGE_EXCHANGE_REALTIME_CANCEL = 53042,   //交易所市场行情--取消推送
class QBPageExchangeRealTime_Req {
 public:
  char m_Code[5];      // 指数代码 //SSE  //SZE
  time_t m_BeginTime;  // 开始时间
  time_t m_EndTime;    // 结束时间
  int m_Limit;         // 条数     -1为全部

  QBPageExchangeRealTime_Req() {
    memset(m_Code, 0, sizeof(m_Code));
    m_BeginTime = m_EndTime = 0;
    m_Limit = -1;
  }
};

class QBPageExchangeRealTime_Unit {
 public:
  char m_Code[5];       // 指数代码
  char m_Price[10];     // 最新
  char m_Open[10];      // 开盘
  char m_Low[10];       // 最低
  char m_High[10];      // 最高
  char m_Close[10];     // 收盘
  char m_PreClose[10];  // 昨收
  time_t m_TradeTime;   // 交易时间
  int m_Milliseconds;   // 毫秒
  QBPageExchangeRealTime_Unit() {
    memset(m_Code, 0, sizeof(m_Code));
    memset(m_Price, 0, sizeof(m_Price));
    memset(m_Open, 0, sizeof(m_Open));
    memset(m_High, 0, sizeof(m_High));
    memset(m_Low, 0, sizeof(m_Low));
    memset(m_Close, 0, sizeof(m_Close));
    memset(m_PreClose, 0, sizeof(m_PreClose));
    m_TradeTime = 0;
    m_Milliseconds = 0;
  }
};

class QBPageExchangeRealTime_Ack {
 public:
  std::list<QBPageExchangeRealTime_Unit> m_List;
};

// E_FID_QB_PAGE_HOT_INTEREST_BOND_REQ = 53043,   //请求市场行情活跃债券
class QBPageHotInterestBond_Req {
 public:
  int m_BondType;  // 0:利率债 1:信用债 2:NCD
  QBPageHotInterestBond_Req() : m_BondType(0) {}
};

class QBPageHotInterestBond_Ack {
 public:
  int m_BondType;
  std::list<TW_BOND> m_Bond;  // 债券信息
  QBPageHotInterestBond_Ack() : m_BondType(0) {}
};

// E_FID_QB_PAGE_BROKER_BOND_DEAL_REQ = 53044,   //银行间债券的成交列表--请求
// E_FID_QB_PAGE_BROKER_BOND_DEAL_PUSH = 53045,   //银行间债券的成交列表--推送
// E_FID_QB_PAGE_BROKER_BOND_DEAL_CANCEL = 53046,
// //银行间债券的成交列表--取消推送
class QBPageBrokerBondDeal_Req {
 public:
  char m_Bondkey[32 + 1];  // key
  char m_Listedmarket[8];  // 市场代码
  time_t m_BeginTime;      // 开始时间
  time_t m_EndTime;        // 结束时间
  int m_Limit;             // 条数
  QBPageBrokerBondDeal_Req() {
    memset(m_Bondkey, 0, sizeof(m_Bondkey));
    memset(m_Listedmarket, 0, sizeof(m_Listedmarket));
    m_BeginTime = m_EndTime = 0;
    m_Limit = -1;
  }
};

class QBPageBrokerBondDeal_Unit {
 public:
  char m_Bondkey[32 + 1];  // key
  char m_Listedmarket[8];  // 市场代码
  char m_BrokerID[8];      // BrokerID,
  char m_Id[32 + 1];       // 唯一编号
  char m_Price[10];        // 成交价
  char m_PreAverage[10];   // 昨日平均
  char m_DealStatus[2];  // 成交状态 //"0 ~ 3: 客户端显示成交，		4 ~ 6:
                         // 客户端删除成交"
  time_t m_TradeTime;  // 交易时间
  QBPageBrokerBondDeal_Unit() : m_TradeTime(0) {
    memset(m_Bondkey, 0, sizeof(m_Bondkey));
    memset(m_Listedmarket, 0, sizeof(m_Listedmarket));
    memset(m_Id, 0, sizeof(m_Id));
    memset(m_Price, 0, sizeof(m_Price));
    memset(m_BrokerID, 0, sizeof(m_BrokerID));
    memset(m_PreAverage, 0, sizeof(m_PreAverage));
    memset(m_DealStatus, 0, sizeof(m_DealStatus));
  }
};
class QBPageBrokerBondDeal_Ack {
 public:
  QBPageBrokerBondDeal_Ack() : m_Reset(false) { ; }
  std::list<QBPageBrokerBondDeal_Unit> m_DealList;
  bool m_Reset;
};
//--------------------------------------------------------------------------------------------------
// E_FID_QB_COMMONPAGE_REQ = 50266,			//QB常用页查询
// 请求：
struct xQBCommonPageReq_c {
  char m_UserAccount[32 + 1];  // 用户Account
  xQBCommonPageReq_c() { memset(this, 0, sizeof(xQBCommonPageReq_c)); };
};
// 应答：
struct xQBCommonPageAck_t {
  std::list<std::string> m_List;
};
// E_FID_QB_COMMONPAGE_ADD_REQ = 50267,			//QB常用页添加
// E_FID_QB_COMMONPAGE_DEL_REQ = 50268,			//QB常用页删除
// 请求：
struct xQBCommonPageModifyReq_t {
  char m_UserAccount[32 + 1];  // 用户Account
  std::string m_page;
  xQBCommonPageModifyReq_t() {
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
  }
};
// 应答，无包体，retcode = 0表示成功

//--------------------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------
// E_FID_QB_FLAGS_REQ							= 50269,
// //QB通用标志位查询

class xQbFlag_c {
 public:
  // Key
  char szKey[33];
  // Value
  char szValue[1024];

  xQbFlag_c() { memset(this, 0, sizeof(xQbFlag_c)); }
  xQbFlag_c(const char* pszkey, const char* pszVal) {
    __FIELDCOPY__(szKey, pszkey);
    __FIELDCOPY__(szValue, pszVal);
  }
};

// req
class xQbFlagsReq_c {
 public:
  // CompanyID
  char m_CompanyID[33];
  // UserID
  char m_UserId[33];
  // Flag
  xQbFlag_c flag_;  // 用于请求指定标识，全量请求时为空
  xQbFlagsReq_c() { memset(this, 0, sizeof(xQbFlagsReq_c)); }
};

// ack
class xQBFlagsAck_c {
 public:
  // CompanyID
  char m_CompanyID[33];
  // UserID
  char m_UserId[33];
  // List
  std::list<xQbFlag_c> listFlags;
  xQBFlagsAck_c() {
    memset(m_CompanyID, 0, sizeof(m_CompanyID));
    memset(m_UserId, 0, sizeof(m_UserId));
    listFlags.clear();
  }
};
//-------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------
// E_FID_QB_FLAGS_ADD_REQ						= 50270,
// //QB通用标志位添加
class xQbFlagAdd_c {
 public:
  // CompanyID
  char m_CompanyID[33];
  // UserID
  char m_UserId[33];
  // Flag
  xQbFlag_c flag_;

  xQbFlagAdd_c() { memset(this, 0, sizeof(xQbFlagAdd_c)); }
};

// 应答，无包体，retcode = 0表示成功
//-------------------------------------------------------------------------------------

//-------------------------------------------------------------------------------------
// E_FID_QB_ABS_CNABS_BASE_INFO_REQ = 59100,
// //ABS_CNABS计算器请求定价状态和四率,服务端违约回收延迟按照月给到客户端
// moody计算器不需要给到四率，但是要给过来定价状态
// E_FID_QB_ABS_MOODY_BASE_INFO_REQ = 59104,
// //ABS_MOODY计算器请求定价状态和四率,服务端违约回收延迟按照月给到客户端
// E_FID_QB_ABS_CHINA_RATING_BASE_INFO_REQ = 59108,
// //ABS_中债资信计算器请求定价状态,服务端违约回收延迟按照月给到客户端
struct xQBABSBaseInfoUnit {
  // 以下字段请求和应答都必须填写
  char m_comBondCode[33];  // combondCode, 如"180210.IB"
  char m_bondCode[33];     // bondCode, 如"180210"
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  // 以下字段属于应答部分字段
  char m_pricingStatus[4];  // 定价状态，"0"和""表示不支持定价，其他表示可定价
  char m_statusTip[4];  // 提示类型，"0"和""表示不提示，"1"提示次级债券不支持定价
  char m_analyseStatus
      [4];  // 是否支持 情景分析，"0"和""表示不支持情景分析，"1"表示支持情景分析
  char m_prePaymentRate[32];       // 早偿率，单位%
  char m_defaultRate[32];          // 违约率，单位%
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  xQBABSBaseInfoUnit() {
    _InitializeString(m_comBondCode);
    _InitializeString(m_bondCode);
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
    _InitializeString(m_pricingStatus);
    _InitializeString(m_statusTip);
    _InitializeString(m_analyseStatus);
    _InitializeString(m_prePaymentRate);
    _InitializeString(m_defaultRate);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
  }
  bool IsCalcValid() {
    if (strcmp(m_pricingStatus, "0") == 0 || strcmp(m_pricingStatus, "") == 0)
      return false;
    return true;
  }
  bool IsEmpty() {
    if (strlen(m_prePaymentRate) == 0 || strlen(m_defaultRate) == 0 ||
        strlen(m_defaultRecoveryRate) == 0 || strlen(m_recoveryDelay) == 0)
      return true;
    return false;
  }
};
// 请求
struct xQBABSBaseInfoReq {
  std::list<xQBABSBaseInfoUnit> m_List;
};
// 应答结构同xQBABSBaseInfoReq
typedef xQBABSBaseInfoReq xQBABSBaseInfoAck;

// E_FID_QB_ABS_CNABS_CAL_REQ = 59101,			//ABS_CNABS计算器调用
//	E_FID_QB_ABS_MOODY_CAL_REQ
//= 59105,			//ABS_MOODY计算器调用
struct xQBABSCalUnit {
  // 以下字段请求和应答都必须填写
  char m_comBondCode[33];  // combondcode, 例如"180210.IB"
  char m_bondCode[33];
  char m_bondKey[33];              // bondkey
  char m_listedMarket[4];          // listedMarket
  char m_prePaymentRate[32];       // 早偿率，单位%
  char m_defaultRate[32];          // 违约率，单位%
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  char m_settlementDate[20];  // 结算日，客户端用YYYY-MM_DD给到后台
  char m_calInputIndicator[4];  // 计算方式,
                                // "0表示为收益率，“1”表示为净价，"2"表示全价,
                                // "3"表示用DM计算
  char m_yield[32];       // 收益率，单位%
  char m_cleanPrice[32];  // 净价，单位为元
  char m_fullPrice[32];   // 全价，单位为元
  char m_dm[32];          // 贴现利差，单位%
  char m_bondTypeFloating[4];  // 债券类型，“1”表示浮息，其他均表示普通债券
  char m_prevailingRate[32];  // 基础利率值，单位%
  // 以下字段为应答字段
  char m_accruedInterest[32];       // 应计利息
  char m_principalFactor[32];       // 本金因子
  char m_convexity[32];             // 凸性
  char m_weightedRemainPeriod[32];  // 加权剩余期限
  char m_fixDuration[32];           // 修正久期
  char m_principalReduction[32];    // 本金减计
  char m_principalWindow[32];       // 本金窗口
  xQBABSCalUnit() {
    _InitializeString(m_comBondCode);
    _InitializeString(m_bondCode);
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
    _InitializeString(m_prePaymentRate);
    _InitializeString(m_defaultRate);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
    _InitializeString(m_settlementDate);
    _InitializeString(m_calInputIndicator);
    _InitializeString(m_yield);
    _InitializeString(m_cleanPrice);
    _InitializeString(m_fullPrice);
    _InitializeString(m_accruedInterest);
    _InitializeString(m_principalFactor);
    _InitializeString(m_convexity);
    _InitializeString(m_weightedRemainPeriod);
    _InitializeString(m_fixDuration);
    _InitializeString(m_principalReduction);
    _InitializeString(m_principalWindow);
    _InitializeString(m_dm);
    _InitializeString(m_bondTypeFloating);
    __FIELDCOPY__(m_bondTypeFloating, "0");  // 默认填写0
    _InitializeString(m_prevailingRate);
  }
};
struct xQBABSRefBondCashFlowUnit {
  // 现金流参数
  char m_size[32];                 // 债券现金流
  char m_dates[16];                // 日期，e.g. 2019-02-17
  char m_balance[32];              // 余额，小数点后四位，单位：亿
  char m_interest[32];             // 利息，小数点后四位，单位：元
  char m_principal[32];            // 本金，单位：亿
  char m_cash[32];                 // 现金，单位：亿
  char m_principal_writedown[32];  // 本金勾销，单位:元
  char m_interest_shortfall[32];   // 利息缺口，单位：元
  char m_interest_due[32];         // 应计利息
  char m_accrual_begin_dates[16];  // 利息起算日 e.g. 2019-02-17
  char m_accrual_days[32];         // 计息天数，整数
  char m_rate[32];                 // 利率，单位%
  char m_flt_index[32];            // 浮动利率基础利率，单位%
  xQBABSRefBondCashFlowUnit() {
    memset(this, 0, sizeof(xQBABSRefBondCashFlowUnit));
  }
};

struct xQBABSRefCollatCashFlowUnit  // 资产池现金流
{
  // 现金流参数
  char m_size[32];             // 资产池现金流长度（月）
  char m_dates[16];            // 日期，e.g. 2019-09-01
  char m_balance[32];          // 余额
  char m_sche_principal[32];   // 计划摊还本金
  char m_prepayments[32];      // 早偿金额
  char m_defaults[32];         // 违约金额
  char m_prin_recoveries[32];  // 本金回收
  char m_cash[32];             // 现金
  char m_interest[32];         // 利息
  char m_sche_p_and_i[32];     // 计划本金和利息
  char m_losses[32];           // 损失
  xQBABSRefCollatCashFlowUnit() {
    memset(this, 0, sizeof(xQBABSRefCollatCashFlowUnit));
  }
};
// 请求
struct xQBABSCalReq {
  std::list<xQBABSCalUnit> m_List;  // 可能会传入不同计算器计算参数
};
// 应答 结构同请求
struct xQBABSCalAck {
  std::list<xQBABSCalUnit> m_List;  // 可能会传入不同计算器计算参数
};

// E_FID_QB_ABS_SCHEME_REQ = 59102,			//ABS自定义四率方案查询
struct xQBABSSchemeUnit {
  int m_rank;  // 方案排序,
               // 从1开始排序，如果有删除，大于该方案m_rank的方案的m_rank做自减处理
  char m_schemeId[32 + 1];  // 方案id, 新增方案，请求会填空，由应答填写具体id
  char m_schemeName[32];  // 方案名称，可能会修改本方案的名称
  char m_prePaymentRate[32];       // 早偿率，单位%
  char m_defaultRate[32];          // 违约率，单位%
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  xQBABSSchemeUnit() {
    m_rank = -1;
    _InitializeString(m_schemeId);
    _InitializeString(m_schemeName);
    _InitializeString(m_prePaymentRate);
    _InitializeString(m_defaultRate);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
  }
  bool operator==(const xQBABSSchemeUnit& unit) {
    return m_rank == unit.m_rank;
  }
  xQBABSSchemeUnit(const xQBABSSchemeUnit& outer) {
    m_rank = outer.m_rank;
    strcpy(m_schemeId, outer.m_schemeId);
    strcpy(m_schemeName, outer.m_schemeName);
    strcpy(m_prePaymentRate, outer.m_prePaymentRate);
    strcpy(m_defaultRate, outer.m_defaultRate);
    strcpy(m_defaultRecoveryRate, outer.m_defaultRecoveryRate);
    strcpy(m_recoveryDelay, outer.m_recoveryDelay);
  }
  xQBABSSchemeUnit& operator=(const xQBABSSchemeUnit& outer) {
    m_rank = outer.m_rank;
    strcpy(m_schemeId, outer.m_schemeId);
    strcpy(m_schemeName, outer.m_schemeName);
    strcpy(m_prePaymentRate, outer.m_prePaymentRate);
    strcpy(m_defaultRate, outer.m_defaultRate);
    strcpy(m_defaultRecoveryRate, outer.m_defaultRecoveryRate);
    strcpy(m_recoveryDelay, outer.m_recoveryDelay);
    return *this;
  }
  bool operator<(const xQBABSSchemeUnit& outer) {
    return m_rank < outer.m_rank;
  }
};
// 请求
typedef xQBBasicRequestWithUser xQBABSSchemeReq;
// 应答
struct xQBABSSchemeAck {
  std::list<xQBABSSchemeUnit> m_List;  // 布局方案
};

//	E_FID_QB_ABS_SCHEME_MDF
//= 59103,			//ABS自定义四率方案修改 请求
struct xQBABSSchemeMdyReq {
  char m_userId[32 + 1];  // 用户id
  int m_mdfType;          // 0表示增加，1表示替换，2表示删除
  xQBABSSchemeUnit m_scheme;  // 增加时候，不会填写schemeid,但是应答结构需要填写；
                              // 修改的时候可能会修改方案名称
  xQBABSSchemeMdyReq() {
    _InitializeString(m_userId);
    m_mdfType = 0;
  }
};

// 应答
struct xQBABSSchemeMdyAck {
  int m_mdfType;  // 0表示增加，1表示替换，2表示删除
  xQBABSSchemeUnit m_scheme;  // 增加时候，不会填写schemeid,但是应答结构需要填写；
                              // 修改的时候可能会修改方案名称
  xQBABSSchemeMdyAck() { m_mdfType = 0; }
};

// E_FID_QB_ABS_BOND_REFERENCE_INFO_REQ = 59110,
// //获取某只券对应的系列参考值

struct xQBABSRefRatesUnit {
  char m_accountAge[32];  // 账龄
  char m_rates[32];       // 利率
  xQBABSRefRatesUnit() {
    _InitializeString(m_accountAge);
    _InitializeString(m_rates);
  }
};
// 请求
struct xQBABSBondReferenceInfoReq {
  char m_comBondCode[33];  // combondcode, 例如"180210.IB"
  char m_bondCode[33];
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  xQBABSBondReferenceInfoReq() {
    _InitializeString(m_comBondCode);
    _InitializeString(m_bondCode);
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
  }
};
// 应答
struct xQBABSBondReferenceInfoAck {
  char m_refName[32];              // 系列名称
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  std::list<xQBABSRefRatesUnit> m_listPrePaymentRate;  // 早偿率List
  std::list<xQBABSRefRatesUnit> m_listDefaultRate;     // 违约率list
  xQBABSBondReferenceInfoAck() {
    _InitializeString(m_refName);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
  }
};

// E_FID_QB_ABS_REF_SCHEME_REQ = 59111,			//ABS系列参考值方案查询
struct
    xQBABSRefInfoUnit  // 针对分包问题，xQBABSRefRatesUnit为轻量数据，由后端定好分包方案
{
  int m_rank;  // 方案排序,
               // 从1开始排序，如果有删除，大于该方案m_rank的方案的m_rank做自减处理
  char m_schemeId[32 + 1];  // 方案id, 新增方案，请求会填空，由应答填写具体id
  char m_schemeName[32];  // 方案名称，可能会修改本方案的名称
  char m_prepayment_growth[32];    // 早偿率月度增长
  char m_default_growth[32];       // 违约率月度增长
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  char m_schemeType[4];  // 自定义类型，辅助使用，不放入服务端
  std::list<xQBABSRefRatesUnit> m_listPrePaymentRate;  // 早偿率List
  std::list<xQBABSRefRatesUnit> m_listDefaultRate;     // 违约率list
  xQBABSRefInfoUnit() {
    m_rank = 0;
    _InitializeString(m_schemeId);
    _InitializeString(m_schemeName);
    _InitializeString(m_prepayment_growth);
    _InitializeString(m_default_growth);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
    _InitializeString(m_schemeType);
  }
  bool operator<(const xQBABSRefInfoUnit& outer) {
    return m_rank < outer.m_rank;
  }
};
// 请求
typedef xQBBasicRequestWithUser xQBABSRefSchemeReq;
// 应答
struct xQBABSRefSchemeAck {
  std::list<xQBABSRefInfoUnit> m_List;  // 方案
};

// E_FID_QB_ABS_REF_SCHEME_MDF = 59112,			//ABS系列参考值方案修改
// 请求
struct xQBABSRefSchemeMdyReq {
  char m_userId[32 + 1];  // 用户id
  int m_mdfType;  // 0表示增加，1表示替换，2表示删除；删除的时候大于本rank后面方案对应rank均自减
  xQBABSRefInfoUnit m_scheme;  // 增加时候，不会填写schemeid,但是应答结构需要填写；
                               // 修改的时候可能会修改方案名称
  xQBABSRefSchemeMdyReq() {
    _InitializeString(m_userId);
    m_mdfType = 0;
  }
};
// 应答
struct xQBABSRefSchemeMdyAck {
  int m_mdfType;  // 0表示增加，1表示替换，2表示删除
  xQBABSRefInfoUnit m_scheme;  // 增加时候，不会填写schemeid,但是应答结构需要填写；
                               // 修改的时候可能会修改方案名称
  xQBABSRefSchemeMdyAck() { m_mdfType = 0; }
};

// E_FID_QB_ABS_MOODY_NEW_CAL_REQ = 59113,
// //moody计算器应答，新版带有参考现金流 E_FID_QB_ABS_CHINA_RATING_CAL_REQ =
// 59109,            //ABS_中债资信计算器应答，结果无需带有参考现金流
// E_FID_QB_ABS_CNABS_NEW_CAL_REQ = 59114,
// //CNABS计算器应答，结果无需填写参考值,结果无需带有参考现金流
struct xQBABSCalUnitNew {
  // 以下字段请求和应答都必须填写
  char m_comBondCode[33];  // combondcode, 例如"180210.IB"
  char m_bondCode[33];
  char m_bondKey[33];         // bondkey
  char m_listedMarket[4];     // listedMarket
  char m_prePaymentRate[32];  // 早偿率，单位%，
                              // 如果是CNABS参考值，会隐含传入CNABS早偿率
  char m_defaultRate
      [32];  // 违约率，单位%，如果是CNABS参考值，会隐含传入CNABS违约率
  char m_defaultRecoveryRate[32];  // 违约回收率，单位为%
  char m_recoveryDelay[32];  // 回收延迟，单位为月，需要服务端转换
  std::list<xQBABSRefRatesUnit> m_listPrePaymentRate;  // 早偿率List
  std::list<xQBABSRefRatesUnit> m_listDefaultRate;     // 违约率list
  char m_schemeType[4];  //"1“或者""表示自定义类型，需要用到早偿率list和违约率list;
                         //"0"表示CNABS类型
  char m_accountAge
      [32];  // 账龄,前端有的话给后台顺便填一下，为""后台自己去Moody那里取
  char m_settlementDate[20];  // 结算日，客户端用YYYY-MM_DD给到后台
  char m_calInputIndicator[4];  // 计算方式,
                                // "0表示为收益率，“1”表示为净价，"2"表示全价,
                                // "3"表示用DM计算
  char m_yield[32];       // 收益率，单位%
  char m_cleanPrice[32];  // 净价，单位为元
  char m_fullPrice[32];   // 全价，单位为元
  char m_dm[32];          // 贴现利差，单位%
  char m_bondTypeFloating[4];  // 债券类型，“1”表示浮息，其他均表示普通债券
  char m_prevailingRate[32];  // 基础利率值，单位%
  // 以下字段为应答字段
  char m_accruedInterest[32];       // 应计利息
  char m_principalFactor[32];       // 本金因子
  char m_convexity[32];             // 凸性
  char m_weightedRemainPeriod[32];  // 加权剩余期限
  char m_fixDuration[32];           // 修正久期
  char m_principalReduction[32];    // 本金减计
  char m_principalWindow[32];       // 本金窗口
  xQBABSCalUnitNew() {
    _InitializeString(m_comBondCode);
    _InitializeString(m_bondCode);
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
    _InitializeString(m_prePaymentRate);
    _InitializeString(m_defaultRate);
    _InitializeString(m_defaultRecoveryRate);
    _InitializeString(m_recoveryDelay);
    _InitializeString(m_settlementDate);
    _InitializeString(m_calInputIndicator);
    _InitializeString(m_yield);
    _InitializeString(m_cleanPrice);
    _InitializeString(m_fullPrice);
    _InitializeString(m_accruedInterest);
    _InitializeString(m_principalFactor);
    _InitializeString(m_convexity);
    _InitializeString(m_weightedRemainPeriod);
    _InitializeString(m_fixDuration);
    _InitializeString(m_principalReduction);
    _InitializeString(m_principalWindow);
    _InitializeString(m_dm);
    _InitializeString(m_bondTypeFloating);
    __FIELDCOPY__(m_bondTypeFloating, "0");  // 默认填写0
    __FIELDCOPY__(m_schemeType, "1");        // 默认填写0
    _InitializeString(m_prevailingRate);
    _InitializeString(m_accountAge);
  }
};
// 请求 ABS_MOODY_NEW_CAL_REQ
struct xQBABSMoodyNewCalReq {
  xQBABSCalUnitNew m_param;  // 放入
};
// 应答 结构同请求
struct xQBABSMoodyNewCalAck {
  xQBABSCalUnitNew m_param;  // 放入
  std::list<xQBABSRefBondCashFlowUnit>
      m_RefBondCashFlowList;  // 参考现金流，使用table格式，便于分包
  std::list<xQBABSRefCollatCashFlowUnit>
      m_RefCollatCashFlowList;  // 资产池现金流
};

// E_FID_QB_ABS_BOND_ACTUAL_INFO_REQ = 59115,
// //获取某只券的实际系列参考值 请求
struct xQBABSBondActualInfoReq {
  char m_comBondCode[33];  // combondcode, 例如"180210.IB"
  char m_bondCode[33];
  char m_bondKey[33];      // bondkey
  char m_listedMarket[4];  // listedMarket
  xQBABSBondActualInfoReq() {
    _InitializeString(m_comBondCode);
    _InitializeString(m_bondCode);
    _InitializeString(m_bondKey);
    _InitializeString(m_listedMarket);
  }
};
// 应答
struct xQBABSBondActualInfoAck {
  int m_nRet;             // 辅助字段，标识是否应答
  char m_accountAge[32];  // 账龄
  std::list<xQBABSRefRatesUnit> m_listPrePaymentRate;  // 该券实际早偿率List
  std::list<xQBABSRefRatesUnit> m_listDefaultRate;  // 该券实际违约率list
  xQBABSBondActualInfoAck() {
    _InitializeString(m_accountAge);
    m_nRet = 0;
  }
};

// E_FID_QB_RT_SPREAD_TAB_SEL_ADMIN_REQ = 59116,
// //查询管理员默认设置的TAB选项
// E_FID_QB_RT_SPREAD_TAB_SEL_USER_REQ = 59120,
// //查询用户设置的TAB选项
struct xQbRtSpreadTabSelReq {
  char m_userId[32 +
                1];  // 用户id,如果是59117,无论id多少，均返回管理员设置好的方案
  char m_version[8];  // 新版本会填写 v2,老版本取不到就认为version为""
};

struct xQbRtSpreadSelUnit {
  int m_pageId;            // 按照pageId来定义每一个窗口的序列
  int m_policySelect;      // 策略选择
  int m_spreadTypeSelect;  // 策略下属tab选择，仅存基差交易
  xQbRtSpreadSelUnit() {
    m_pageId = 0;
    m_policySelect = 0;
    m_spreadTypeSelect = 0;
  }
};
struct xQbRtSpreadTabSelAck {
  std::list<xQbRtSpreadSelUnit> m_list;  // 各个页面对应的tab选项集合
};

// E_FID_QB_RT_SPREAD_TAB_SEL_ADMIN_MDY = 59117,
// //管理员修改默认设置的TAB选项 E_FID_QB_RT_SPREAD_TAB_SEL_USER_MDY = 59121,
// //用户修改设置的TAB选项

struct xQbRtSpreadTabSelMdy {
  char m_userId[32 +
                1];  // 用户id,如果是59117,无论id多少，均返回管理员设置好的方案
  char m_version[8];  // 新版本会填写 v2,老版本取不到就认为version为""
  xQbRtSpreadSelUnit
      m_tabSel;  // pageId不会重复，如果原本的pageId不存在，新增；pageId存在，替换
  xQbRtSpreadTabSelMdy() { _InitializeString(m_userId); }
};

struct xQbRtSpreadTabSelMdyAck  // 应答和请求保持一致，客户端收到应答后替换
{
  char m_userId[32 +
                1];  // 用户id,如果是59116,无论id多少，均返回管理员设置好的方案
  xQbRtSpreadSelUnit
      m_tabSel;  // pageId不会重复，如果原本的pageId不存在，新增；pageId存在，替换
  xQbRtSpreadTabSelMdyAck() { _InitializeString(m_userId); }
};

// E_FID_QB_RT_SPREAD_SCHEME_ADMIN_REQ = 59118,
// //查询管理员默认设置的方案选项 E_FID_QB_RT_SPREAD_SCHEME_USER_REQ = 59122,
// //查询用户设置的方案选项

typedef xQBBasicRequestWithUser xQbRtSpreadSchemeReq;

struct xQbRtSpreadSchemeUnit {
  int m_pageId;       // 页面序号
  int m_policyType;   // 策略类型
  int m_subType;      // 子类型，基差交易策略时用以识别下属类
  int m_bondPrcType;  // 债券指标取值，0为报价，1为成交	; left取值，也可能是期货
  int m_futurePrcType;    // 期货指标取值，0为报价，1为成交
  char m_indexType[8];    // 净基差使用，资金成本类型
  char m_indexValue[20];  // 资金成本附带值，可能为bp值，也可能为具体设置自定义值;
                          // 使用^分割。资金成本^bp
  int m_sourceType;  // 0表示经纪商，1表示X-Bond，2表示经纪商+X-bond
  std::list<std::string>
      m_subScheme;  // 由客户端进行序列化和反序列化，最长方案数量为11个，单个最长保守估计为114字节,需要预留一定buffer
                    // 序列化格式示例：2 + 2 + 21 + 9 + 21 + 9 + 21 + 9 + 21 + 9
                    // + 9 + 9 ；
  // 是否标题（0/1) | 是否开关(0/1) | 债券代码(20) | 乘数（8）|
  // 债券2代码（20）|乘数（8）|利差名称（20）|利差下限（8）|利差上限（8）|
  // 报量下限（8）
  // 后台使用;分割，前端严格限制字符不允许出现;
  // 前端使用|分割；严格限制字符不允许出现

  xQbRtSpreadSchemeUnit()
      : m_pageId(0),
        m_policyType(0),
        m_subType(0),
        m_bondPrcType(0),
        m_futurePrcType(0),
        m_sourceType(0) {
    _InitializeString(m_indexType);
    _InitializeString(m_indexValue);
  }
};
struct xQbRtSpreadSchemeAck {
  std::list<xQbRtSpreadSchemeUnit>
      m_scheme;  // m_pageId+m_policyType+m_subType标识唯一scheme
};

// E_FID_QB_RT_SPREAD_SCHEME_ADMIN_MDY = 59119,
// //管理员修改默认设置的方案选项 E_FID_QB_RT_SPREAD_SCHEME_USER_MDY = 59123,
// //修改用户设置的方案选项
struct xQbRtSpreadSchemeMdy {
  char m_userId[32 + 1];  // 用户id,对59119用户id不需要考虑
  std::list<xQbRtSpreadSchemeUnit>
      m_scheme;  // 直接替换
                 // m_pageId+m_policyType+m_subType标识唯一scheme。如果该scheme不存在，则新增；如果存在，则直接替换
  xQbRtSpreadSchemeMdy() { _InitializeString(m_userId); }
};

typedef xQbRtSpreadSchemeAck xQbRtSpreadSchemeMdyAck;  // 应答结构同59118和59122

// E_FID_QB_RT_SPREAD_HIS_STATISTIC_REQ = 59124,
// //实时利差列表统计概览
struct sRtSpreadPolityRange  // 策略方案
{
  char m_policyType[8];  // 策略类型 bond\basis\future\curve
  char m_subType[10];  // 子类型，基差交易策略时用以识别下属类
                       // irr\basis\net_basis
  char m_range[5];  // 3M\6M\1Y\YTD 四种曲线类型
  char m_fundIndex
      [14];  // 资金类型
             // FR001\FR007\FR014\GC001\GC002\GC003\GC004\GC007\GC014\Shibor_O_N\Shibor_3M\Custom
  int m_bp;             // bp值
  char m_fundRate[12];  // 如果是自定义资金，需要使用该值
  sRtSpreadPolityRange() { memset(this, 0, sizeof(sRtSpreadPolityRange)); }
};

struct sRtSpreadMonitorUnit  // 监控对象
{
  char m_tag[64];  // 客户端特殊确定tag, 会将参数组合作为tag, 避免重复请求
  char m_typeLeft[8];   // 左端类型 bond\future
  char m_proLeft[32];   // 债券填写bondkey, 期货填写tfid
  char m_mulLeft[12];   // 左端乘数
  char m_typeRight[8];  // 左端类型 bond\future
  char m_proRight[32];  // 债券填写bondkey, 期货填写tfid
  char m_mulRight[12];  // 左端乘数
  sRtSpreadMonitorUnit() { memset(this, 0, sizeof(sRtSpreadMonitorUnit)); }
};

struct sRtSpreadMonitorHisStatisticUnit {
  char m_tag[64];  // 客户端特殊确定tag, 会将参数组合作为tag, 避免重复请求
  double m_max;  // 最大值，如果无效或者计算不出来，不要填写到消息内
  double m_min;     // 最小值
  double m_avg;     // 平均值
  double m_latest;  // 最新值
  sRtSpreadMonitorHisStatisticUnit() {
    memset(this, 0, sizeof(sRtSpreadMonitorHisStatisticUnit));
  }
};

struct sRtSpreadMonitorHisStreamUnit {
  int m_date;         // 日期 20201231
  double m_value;     // 对应日期的计算结果
  double m_prcLeft;   // 左端对应的值
  double m_prcRight;  // 右端对应的值
  sRtSpreadMonitorHisStreamUnit() {
    memset(this, 0, sizeof(sRtSpreadMonitorHisStreamUnit));
  }
};

// 请求
struct xQBRtSpreadHisStatisticReq {
  sRtSpreadPolityRange m_policy;
  std::list<sRtSpreadMonitorUnit> m_lstMonitor;  // 多列表请求
};

// 应答
struct xQBRtSpreadHisStatisticAck {
  sRtSpreadPolityRange m_policy;
  std::list<sRtSpreadMonitorHisStatisticUnit> m_lstResult;  // 统计数据
};

// E_FID_QB_RT_SPREAD_SINGLE_HIS_STREAM_REQ = 59125,
// //实时利差单列表日线请求 请求
struct xQBRtSpreadSingleHisStreamReq {
  sRtSpreadPolityRange m_policy;
  sRtSpreadMonitorUnit m_monitor;
};
// 应答
struct xQBRtSpreadSingleHisStreamAck {
  sRtSpreadPolityRange m_policy;
  std::list<sRtSpreadMonitorHisStreamUnit> m_lstDaily;  // 日线数据
};

// E_FID_QB_REMINDER_PASSIVE_PUSH = 50814,
// //QB被动提醒，通用，不用注册，网关主动推送 无请求 应答
struct xQBReminderPassiveAck {
  int m_pageid;  // 点击打开pageid
  int m_delay;   // 提醒显示延时关闭，单位秒，<=0则不关闭
  std::string m_pageparam;  // 打开页面参数（web）
  std::string m_title;
  std::string m_content;
  std::string m_jumpparam;  // 跳转描述，本次新增
  xQBReminderPassiveAck() : m_pageid(-1), m_delay(0){};
};

// E_FID_QB_REMINDER_HTTP_PUSH					= 50837,
// //QB被动提醒，增加http推送内容，类似50814 无情求？？ 应答 同 xQBNormalHttpAck

// E_FID_QB_BOND_CDC_SPECIAL_INFO = 53048,	//请求债券中债估值特殊信息
class xQBBondCDCSpecialInfoReq_t {
 public:
  std::list<TW_BOND> m_Bond;  // 债券信息
};

class xQBBondCDCSpecialInfoUnit_c {
 public:
  char m_bond_key[32 + 1];   // Sumscope的BondKey	String
  char m_listedmarket[8];    // 市场代码
  char m_CDCCleanPrice[10];  // 中债估值净价
  char m_CDCFullPrice[10];   // 中债估值全价
  char m_CDCYield[10];       // 中债估值收益率
  int m_BondProperty;        // 债券属性 0:正常券  1:违约券
                       // 2:查不到该券(非违约券,也不是crm cln以及对应的标的券)
  UINT m_Date;  // 中债估值日期

  xQBBondCDCSpecialInfoUnit_c() {
    _InitializeString(m_bond_key);
    _InitializeString(m_listedmarket);
    _InitializeString(m_CDCCleanPrice);
    _InitializeString(m_CDCFullPrice);
    _InitializeString(m_CDCYield);
    m_Date = 0;
    m_BondProperty = 0;
  }
};

class xQBBondCDCSpecialInfoListAck_c {
 public:
  std::list<xQBBondCDCSpecialInfoUnit_c> m_List;  //
};

// E_FID_QB_FI_COMP_CREDIT_PRI_REQ = 50822,
// //固收综合屏，信用债一级发行计划，请求 E_FID_QB_FI_COMP_CREDIT_PRI_PUSH =
// 50823,			//固收综合屏，信用债一级发行计划，注册推送 请求
struct xQBFICompCreditPriReq {
  int m_Version;  // 日内自清版本号，用于增量请求，首次请求 0
  xQBFICompCreditPriReq() : m_Version(0){};
};

// 应答
struct xQBFICompCreditPriUnit {
  char m_BondKey[33];       // key
  char m_Name[256];         // 发行人/债券
  char m_IssueDate[32];     // 发行时间
  char m_MaturityTerm[64];  // 期限
  char m_IssueAmount[64];   // 发行规模
  char m_IssuerRating[16];  // 主体评级
  char m_BondRating[16];    // 债项
  //	char m_Rating[64];			//评级, 主/债
  char m_CouponRate[64];  // 利率
  char m_isToday[8];      // 是否当日，0=非当天，1=当天，-1=删除
  xQBFICompCreditPriUnit() { memset(this, 0, sizeof(xQBFICompCreditPriUnit)); }
  bool operator==(const xQBFICompCreditPriUnit& one) const {
    return (strcmp(m_BondKey, one.m_BondKey) == 0);
  }
};
struct xQBFICompCreditPriAck {
  std::list<xQBFICompCreditPriUnit> m_List;
  int m_Version;  // 日内自清版本号，用于增量请求
  xQBFICompCreditPriAck() : m_Version(0){};
};

// E_FID_QB_FI_COMP_NCD_PRI_REQ = 50825,
// //固收综合屏，NCD一级成交，请求 请求无包体 应答
class xQBFICompNCDPriInstUnit {
 public:
  char m_Name[16];    // 机构名称
  char m_NameEn[64];  // 机构英文名称
  char m_Price[16];   // 该机构报价
  char m_Change[16];  // 涨跌
  xQBFICompNCDPriInstUnit() {
    memset(this, 0, sizeof(xQBFICompNCDPriInstUnit));
  }
  ~xQBFICompNCDPriInstUnit() { int xxx = 0; }
};

class xQBFICompNCDPriUnit {
 public:
  char m_Term[16];                                // 期限
  char m_Rating[16];                              // 评级
  char m_AviPrice[16];                            // 平均价格
  char m_AviChange[16];                           // 均价涨跌
  std::list<xQBFICompNCDPriInstUnit> m_InstList;  // 机构明细
  xQBFICompNCDPriUnit() { Clear(); }
  void Clear() {
    memset(m_Term, 0, sizeof(m_Term));
    memset(m_Rating, 0, sizeof(m_Rating));
    memset(m_AviPrice, 0, sizeof(m_AviPrice));
    memset(m_AviChange, 0, sizeof(m_AviChange));
    m_InstList.clear();
  }
  ~xQBFICompNCDPriUnit() { int xxx = 0; }
};

struct xQBFICompNCDPriAck {
  std::list<xQBFICompNCDPriUnit> m_TermList;  // 期限明细
};

// E_FID_QB_FI_COMP_NCD_PRI_PUSH = 50826,
// //固收综合屏，NCD一级成交，注册推送 注册无包体
// 应答，单机构报价有变动，都需要推送
struct xQBFICompNCDPriPushAck {
  char m_Term[16];        // 期限
  char m_Rating[16];      // 评级
  char m_AviPrice[16];    // 平均价格
  char m_AviChange[16];   // 均价涨跌
  char m_InstName[16];    // 机构名称
  char m_InstNameEn[64];  // 机构英文名称
  char m_Price[16];       // 该机构报价
  char m_Change[16];      // 该机构报价涨跌
  int m_PriceStatus;      // 0,正常报价, 1,报价删除
  xQBFICompNCDPriPushAck() { memset(this, 0, sizeof(xQBFICompNCDPriPushAck)); }
};

// E_FID_QB_BOND_CREDIT_SPREAD_REQ = 59106,			//个券信用利差
struct xQBBondCreditSpreadReq {
  char m_bond_key[32 + 1];  // Sumscope的BondKey	String
  char m_listed_market[8];  //
  int m_date_begin;         // 查询开始时间,-1 表示全部
  int m_date_end;           // 查询结束时间,-1 表示全部
  xQBBondCreditSpreadReq() : m_date_begin(-1), m_date_end(-1) {
    _InitializeString(m_bond_key);
    _InitializeString(m_listed_market);
  }
};

class xQBBondCreditSpreadAckUnit {
 public:
  int m_date;                     // 格式例如20191216
  char m_spread[12];              // 个券信用利差
  char m_espread[12];             // 个券超额利差
  char m_Val_Yield[12];           // 中债估值收益率
  char m_yield_avg[12];           // 个券收益率
  char m_gk_Yield[12];            // 国开曲线收益率
  char m_zz_Yield[12];            // 中债曲线收益率
  char m_rating_change_flag[20];  //"U"表示评级上调,
                                  //“D”表示下调，不填或者"N"表示评级不变
                                  ////多条评级"|" 分割开
  char m_rating_prev[48];  // 之前评级
                           // //多条评级"|" 分割开
  char m_rating_cur[48];  // 现在调整后的评级
                          // //多条评级"|" 分割开
  char m_issuerCode[80];  // 评级机构代码
                          // //多条评级"|" 分割开 最多9个
  xQBBondCreditSpreadAckUnit() : m_date(-1) {
    _InitializeString(m_spread);
    _InitializeString(m_rating_change_flag);
    _InitializeString(m_rating_prev);
    _InitializeString(m_rating_cur);
    _InitializeString(m_issuerCode);
  }
};

struct xQBBondCreditSpreadAck {
  char m_bond_key[32 + 1];                       // Sumscope的BondKey	String
  char m_listed_market[8];                       //
  std::list<xQBBondCreditSpreadAckUnit> m_list;  // 应答数据
  xQBBondCreditSpreadAck() {
    _InitializeString(m_bond_key);
    _InitializeString(m_listed_market);
  }
};

// E_FID_QB_ISSUER_CREDIT_SPREAD_REQ = 59107,			//主体信用利差
struct xQBIssuerCreditSpreadReq {
  char m_issuer_code[32 + 1];  // 主体代码
                               // //
  int m_date_begin;  // 查询开始时间,-1 表示全部
  int m_date_end;    // 查询结束时间,-1 表示全部
  xQBIssuerCreditSpreadReq() : m_date_begin(-1), m_date_end(-1) {
    _InitializeString(m_issuer_code);
  }
};

struct xQBIssuerCreditSpreadAck {
  char m_issuer_code[32 + 1];  // 主体代码
  std::list<xQBBondCreditSpreadAckUnit>
      m_list;  // 应答数据,主体没有评级变动可不填
  xQBIssuerCreditSpreadAck() { _InitializeString(m_issuer_code); }
};

// E_FID_QB_TF_STATISTICS_FUTURE_COMPANIES_QRY = 52710,
// //TF统计持仓_期货公司查询
typedef xQBBasicRequestWithUser xQbFutureCompaniesReq;
struct xQbFutureCompanyItem {
  // member_code
  char m_member_code[8];
  // member_abbr
  char m_member_abbr[64];

  xQbFutureCompanyItem() {
    _InitializeString(m_member_code);
    _InitializeString(m_member_abbr);
  }
};

struct xQbFurtureCompaiesAck {
  // list
  std::list<xQbFutureCompanyItem> m_list;
  xQbFurtureCompaiesAck() { m_list.clear(); }
};

// E_FID_QB_NEW_ATTENTION_BLACKLIST_QRY      = 52512,			//
// 我的关注NEw请求黑名单
typedef xQBBasicRequestWithUser xQBNewAttentionBlackListQryReq_t;

// 发行人信息
class xQBNewAttentionBlackListInfo_c {
 public:
  char m_IssuerCode[32 + 1];  // 发行人Code
  char m_IssuerName[64];  // 发行人Name         !!!备用，暂时不需要传
  char m_IssuerNameEn[64];  // 发行人NameEn     !!!备用，暂时不需要传
  xQBNewAttentionBlackListInfo_c() {
    memset(m_IssuerCode, 0, sizeof(m_IssuerCode));
    memset(m_IssuerName, 0, sizeof(m_IssuerName));
    memset(m_IssuerNameEn, 0, sizeof(m_IssuerNameEn));
  }
};
// 应答结构
class xQBNewAttentionBlackListAck_c {
 public:
  std::list<xQBNewAttentionBlackListInfo_c> m_List;
};

// E_FID_QB_NEW_ATTENTION_BLACKLIST_ADD     = 52513,			//
// 我的关注NEw添加黑名单 E_FID_QB_NEW_ATTENTION_BLACKLIST_DELETE = 52514,
// // 我的关注NEw删除黑名单
typedef struct xQBNewAttentionBlackListModifyReq_t {
  char m_UserId[32 + 1];  // 用户id
  std::list<xQBNewAttentionBlackListInfo_c> m_List;
  xQBNewAttentionBlackListModifyReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
  }
} QBNewAttentionBlackListModifyReq_t, *PQBNewAttentionBlackListModifyReq_t;

typedef QBNewAttentionBlackListModifyReq_t QBNewAttentionBlackListModifyAck;

// 无应答体,errorcode 返回0就表示成功

// E_FID_QB_CDC_AREA_PRICE_QRY = 52515,
// //请求某些特定区间的中债估值数据

// CDC数据当日不变动
// 请求是对应数据为空,返回时填写
typedef struct xQBCDCAreaPriceBond {
  xQBCDCAreaPriceBond& operator=(const xQBCDCAreaPriceBond& obj) {
    __FIELDCOPY__(m_BondKey, obj.m_BondKey);
    __FIELDCOPY__(m_ListedMarket, obj.m_ListedMarket);
    __FIELDCOPY__(m_CDCToday, obj.m_CDCToday);
    __FIELDCOPY__(m_CDC3M, obj.m_CDC3M);
    __FIELDCOPY__(m_CDC6M, obj.m_CDC6M);
    __FIELDCOPY__(m_CDC1Y, obj.m_CDC1Y);
    __FIELDCOPY__(m_CDCYBegin, obj.m_CDCYBegin);
    return *this;
  }

  char m_BondKey[32 + 1];  // bondKey;唯一
  char m_ListedMarket[8];  // 市场代码
  char m_CDCToday[10];     // 当日CDC
  char m_CDC3M[10];        // 3个月前CDC
  char m_CDC6M[10];        // 6个月前CDC
  char m_CDC1Y[10];        // 1年前CDC
  char m_CDCYBegin[10];    // 年初CDC
  xQBCDCAreaPriceBond() {
    memset(m_BondKey, 0, sizeof(m_BondKey));
    memset(m_ListedMarket, 0, sizeof(m_ListedMarket));
    memset(m_CDCToday, 0, sizeof(m_CDCToday));
    memset(m_CDC3M, 0, sizeof(m_CDC3M));
    memset(m_CDC6M, 0, sizeof(m_CDC6M));
    memset(m_CDC1Y, 0, sizeof(m_CDC1Y));
    memset(m_CDCYBegin, 0, sizeof(m_CDCYBegin));
  }
} QBCDCAreaPriceBond, *PQBCDCAreaPriceBond;

typedef struct xQBCDCAreaPriceReq_t {
  std::list<xQBCDCAreaPriceBond> m_BondList;
} QBCDCAreaPriceReq_t, *PQBCDCAreaPriceReq_t;

typedef xQBCDCAreaPriceReq_t xQBCDCAreaPriceACK;

// E_FID_QB_HOMEPAGE_CLICK_LOG_REQ = 50835, //首页点击事件统计 请求
struct xQBHomepageClickKLogReq {
  char m_UserId[32 + 1];       // 用户id
  char m_UserAccount[32 + 1];  // 用户登录名
  char m_event[16];            // 事件类型
  char m_type[16];             // 广告/活动/推荐功能等
  char m_id[128];              // 广告id
  std::string m_strUrl;        // 完整的URL
  xQBHomepageClickKLogReq() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_UserAccount, 0, sizeof(m_UserAccount));
    memset(m_event, 0, sizeof(m_event));
    memset(m_type, 0, sizeof(m_type));
    memset(m_id, 0, sizeof(m_id));
  }
};
// 无应答

// E_FID_QB_COMPANYLOGO_REQ = 50836,			//请求机构logo
// 请求
struct xQBCompanyLogoReq {
  char m_underwriterId[32 + 1];  // 机构id
  char m_ver[32];                // 版本号，初始为空
};
// 应答
struct xQBCompanyLogoBuffer {
  char m_buffer[40960];
  int m_bufferLength;
  xQBCompanyLogoBuffer() { memset(this, 0, sizeof(xQBCompanyLogoBuffer)); }
};

struct xQBCompanyLogoAck {
  char m_underwriterId[32 + 1];  // 机构id
  char m_ver[32];                // 版本号
  std::map<std::string, xQBCompanyLogoBuffer> m_files;
  // std::vector<std::string>	m_fileName;		//文件名 logo_main.png /
  // logo_qrcode.png / logo_mini.png / logo_list.png 图片文件以rawdata格式发送
};

// E_FID_QB_COMPANYLOGO_CHANGE_PUSH = 50837, //机构logo更新推送
// 无需注册，全市场推送
// 推送结构
typedef xQBCompanyLogoReq xQBCompanyLogoChangeAck;

// E_FID_QB_HTTP_REQ = 50838,
// //通用接口，通过后台服务访问http服务 E_FID_QB_HTTP_REQ = 50842,
// //通用接口，通过后台访问http服务，请求+更新推送，替换50838 请求
struct xQBNormalHttpReq {
  char m_UserId[32 + 1];  // 用户Id，预留
  std::string m_strUrl;   // URL地址
  std::string
      m_strKey;  // 主键，当strKey为空时，作为一次性请求应答，不在网关记录注册信息
  int m_secTimeout;  // 超时设置，单位秒
  int m_Frequency;   // 循环时间，单位秒，默认为0，不循环
  xQBNormalHttpReq() : m_secTimeout(5), m_Frequency(0){};
};
// 应答
struct xQBNormalHttpAck {
  int m_errorCode;          // 错误码
  std::string m_strKey;     // 标识符
  std::string m_strResult;  // 网页返回字符串
  xQBNormalHttpAck() : m_errorCode(0){};
};

// E_FID_QB_HTTPFILE_REQ = 50839,
// //通用接口，通过后台获取http文件 请求同50838 应答
struct xQBNormalHttpFileAck {
  int m_errorCode;       // 错误码
  int m_totalLength;     // 文件总长度，注意不是本包长度
  int m_bufferLength;    // 本包长度
  char m_buffer[40960];  // 文件buffer
  xQBNormalHttpFileAck() { memset(this, 0, sizeof(xQBNormalHttpFileAck)); }
};

// added by shiy20210729
//  E_FID_QB_BOND_CAL_SPECIFIC_ITEMS_REQ = 50332,
//  //债券计算器特殊条款请求 请求
struct xBondCalSpecificItemsReq_c {
  char m_BondKey[32 + 1];  // bondKey;				唯一
  char m_ListedMarket[8];  // 市场代码
  xBondCalSpecificItemsReq_c() {
    memset(this, 0, sizeof(xBondCalSpecificItemsReq_c));
  };
};
// 应答
struct sSpecificItems {
  char strbond_key[32 + 1];
  char strtype[30];
  char strterms_conditions[1000];
};

class xBondCalSpecificItemsReqAck {
 public:
  int errCode;  // 0表示成功，其他为错误，目前已知：1：请求http失败，99：参数有误
  std::list<sSpecificItems> m_SpecificItems;  // 条款是个数组
};

// E_FID_QB_CDC_PRICE_SINGLE_BOND_HIS_REQ = 50681,
// //请求单券历史中债估值，行权/到期 E_FID_QB_CSI_PRICE_SINGLE_BOND_HIS_REQ =
// 50682,			//请求单券历史中证估值，行权/到期 请求同 50346
// xQBCDCPriceSingleHisReq_t，推荐非推荐不填 应答
struct xQBCDCPriceSingleDay_c {
  char m_CleanPrice[16];  // 净价
  char m_FullPRice[16];   // 全价
  char m_Yield[16];       // 收益率
};

struct xQBCDCPriceSingleDayFull_c {
 public:
  int m_Date;  // 日期
  xQBCDCPriceSingleDay_c m_Option;
  xQBCDCPriceSingleDay_c m_Maturity;

 public:
  xQBCDCPriceSingleDayFull_c() { clear(); };
  void clear() {
    m_Date = 0;
    memset(&m_Option, 0, sizeof(xQBCDCPriceSingleDay_c));
    memset(&m_Maturity, 0, sizeof(xQBCDCPriceSingleDay_c));
  }
  bool operator<(const xQBCDCPriceSingleDayFull_c& obj) const {
    return m_Date < obj.m_Date;
  };
};

struct xQBCDCPriceSingleBondHisAck_c {
 public:
  char m_bond_key[32 + 1];
  char m_listed_market[8];
  std::list<xQBCDCPriceSingleDayFull_c> m_list;
  xQBCDCPriceSingleBondHisAck_c() {
    _InitializeString(m_bond_key);
    _InitializeString(m_listed_market);
  }
};

// E_FID_QB_BOND_LIQUIDITY_FULL_REQ_V2 = 50708,
// //请求债券流动性评分全量 请求
struct xQBBondLiquidityFullReq_c {
  char m_UserId[32 + 1];     // 用户id
  char m_CompanyID[32 + 1];  // 用户所在机构ID
  xQBBondLiquidityFullReq_c() {
    memset(this, 0, sizeof(xQBBondLiquidityFullReq_c));
  }
};

// 应答
struct xQBBondLiquidityUnit {
 public:
  char m_bondkey[32 + 1];  // key
  char m_listedmarket[8];  // 市场代码
  char m_liquidLevel[4];  // 流动性，ABCD，请求不填写，应答给到这个字段
  char m_liquid[16];  // 流动性，百分比
  xQBBondLiquidityUnit() { Clear(); }
  void Clear() {
    _InitializeString(m_bondkey);
    _InitializeString(m_listedmarket);
    _InitializeString(m_liquidLevel);
    _InitializeString(m_liquid);
  }
  xQBBondLiquidityUnit& operator=(xQBBondLiquidityUnit& one) {
    memcpy(this, &one, sizeof(xQBBondLiquidityUnit));
    return *this;
  }
};

// 应答
class xQBBondLiquidityFullAck_c {
 public:
  std::list<xQBBondLiquidityUnit> m_List;  // 应答
};

// E_FID_QB_ISSUER_LIQUIDITY_FULL_REQ_V2 = 50709,
// //请求主体流动性评分全量 请求同50708
typedef xQBBondLiquidityFullReq_c xQBIssuerLiquidityFullReq_c;
// 应答
struct xQBIssuerLiquidityUnit {
 public:
  char m_IssuerCode[32 + 1];  // 发行人代码
  char m_liquidLevel[4];  // 流动性，ABCD，请求不填写，应答给到这个字段
  char m_liquid[16];  // 流动性，百分比
  xQBIssuerLiquidityUnit() { memset(this, 0, sizeof(xQBIssuerLiquidityUnit)); }
  void Clear() { memset(this, 0, sizeof(xQBIssuerLiquidityUnit)); }
  xQBIssuerLiquidityUnit& operator=(xQBIssuerLiquidityUnit& one) {
    memcpy(this, &one, sizeof(xQBIssuerLiquidityUnit));
    return *this;
  }
};
struct xQBIssuerLiquidityFullAck_c {
 public:
  std::list<xQBIssuerLiquidityUnit> m_List;
};

// E_FID_QB_HIGT_YIELD_BOND_QRY = 50712,	//高收益债查询
// 请求
typedef struct xQBHighYieldBondListReq_t {
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  xQBHighYieldBondListReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_CompanyId, 0, sizeof(m_CompanyId));
  }
} QBHighYieldBondListReq_t, *PQBHighYieldBondListReq_t;

// 应答
typedef struct _tag_QBHighYieldBond {
  char m_bondkey[32 + 1];  // 产品ID== bondkey
  char m_listedmarket[8];  // 市场代码
  _tag_QBHighYieldBond() { memset(this, 0, sizeof(_tag_QBHighYieldBond)); };
} QBHighYieldBond;

class xQBHighYieldBondListAck_c {
 public:
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  std::list<QBHighYieldBond> m_List;
  xQBHighYieldBondListAck_c() {
    memset(m_UserId, 0, 33);
    memset(m_CompanyId, 0, 33);
  };
};

////////////////////////////////////////////////////////////////////////////////
// E_FID_QB_ABBOND_RECOMMEND_PRICE_REQ = 50713,			//AB推荐定价查询
// 请求
struct xQBAbBondRecommendPriceReq_t {
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  UINT m_FromVer;
  xQBAbBondRecommendPriceReq_t() {
    memset(this, 0, sizeof(xQBAbBondRecommendPriceReq_t));
  };
};
// 应答
struct xQBAbBondRecommendPriceUnit {
 public:
  char m_bond_key[32 + 1];
  char m_listed_market[8];
  char m_price[12 + 1];
  xQBAbBondRecommendPriceUnit() {
    memset(this, 0, sizeof(xQBAbBondRecommendPriceUnit));
  }
};

struct xQBAbBondRecommendPriceAck_t {
  std::list<xQBAbBondRecommendPriceUnit> m_list;
};
// E_FID_QB_ABBOND_RECOMMEND_PRICE_PUSH = 50714,
// //AB推荐定价订阅推送 E_FID_QB_ABBOND_RECOMMEND_PRICE_PUSH_CANCEL = 50715,
// //AB推荐定价取消订阅 注册无包体，应答同50713

// E_FID_QB_BOND_FACE_VALUE                    = 50719, //查询最新面值 请求
typedef struct xQBABondFaceValueReq_t {
  char m_bond_key[32 + 1];
  char m_listed_market[8];
} QBABondFaceValueReq_t, *PQBABondFaceValueReq_t;

// 响应
class xQBABondFaceValueAck_c {
 public:
  char m_bond_key[32 + 1];
  char m_listed_market[8];
  double m_LatestValue;  // 最新面值

  xQBABondFaceValueAck_c() { m_LatestValue = -1; }
};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// E_FID_MARKETMAKE_TARGET_BOND_REQ			= 50293,
// // 请求最优报价做市标的券筛选 请求
struct xQBMarketMakeTargetReq_c {
  std::list<std::string>
      m_listSectionId;  // 请求 '07120102',
                        // '07120104','07120101','07120103','07120202','07120201'
};
// 应答
struct xQBMarketMakeTargetUnit_c {
  char m_sectionId[16];    // sectionId
  char m_comBondCode[33];  // comBondCode, 例如"180210.IB"
};
struct xQBMarketMakeTargetAck_c {
  std::list<xQBMarketMakeTargetUnit_c> m_list;
};

///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// E_FID_QB_MIXED_BESTQUOTE_REQ = 50933,			//
// 请求经纪商综合最优报价，全市场
// 请求
struct xQBMixedBestQuoteReq {
  char m_contributorId[32 + 1];  // SPBK, SPBK0, SPBK1, SPBK2, SPBK3
  int m_versionFrom;             // 默认为0，表示从头开始。
  int m_versionTo;  // 默认为0，表示一直到最后一个版本
  xQBMixedBestQuoteReq() { memset(this, 0, sizeof(xQBMixedBestQuoteReq)); };
};
// 应答
struct xQBMixedBestQuoteUnit_c {
 public:
  char m_bondkey[33];       // 产品ID',== bondkey
  char m_listedmarket[8];   // 市场代码
  char m_messageSeq[33];    // 消息唯一编号，message sequence
  char m_contributorId[8];  // 清算速度,SPBK,SPBK0,SPBK1,SPBK2,SPBK3
  int m_version;            // 日内自增
  time_t m_modifyTime;      // 最后更新时间

  char m_bidQuoteStatus[8];  // bid报价状态，对应
                             // BidQuoteStatus，多组，故使用string类型，以下同
  char m_bidPrice[12];       // bid原始报价，对应待定
  char m_bidYield[12];       // bid收益率，对应 Entry.BidYield
  char m_bidNetPrice[12];    // bid净价，对应 Entry.BidPrice
  char m_bidFullPrice[12];   // bid全价，对应 Entry.BidDirtyPrice
  char m_bidVolumn[64];      // bid报量，对应 Entry.BidVolume
  char m_bidInterpret[128];  // bid清算速度，对应待定
  char m_bidQuoteType[4];    // bid原始报价类型，对应待定
  char m_bidBarginFlag[8];   // bid可议价标志，对应 Entry.BidBargainFlag
  char m_bidRelationFlag[8];  // bid打包和 OCO标志，对应 Entry.BidRelationFlag
  char m_bidExercise[8];    // bid行权标志，对应 Entry.BidExerciseFlag
  char m_bidCompanyId[33];  // bid报价方，对应 Entry.bidContributorID

  char m_ofrQuoteStatus[8];  // ofr报价状态，对应 OfrQuoteStatus
  char m_ofrPrice[12];       // ofr原始报价，对应待定
  char m_ofrYield[12];       // ofr收益率，对应 Entry.AskYield
  char m_ofrNetPrice[12];    // ofr净价，对应 Entry.AskPrice
  char m_ofrFullPrice[12];   // ofr全价，对应 Entry.AskDirtyPrice
  char m_ofrVolumn[64];      // ofr报量，对应 Entry.AskVolume
  char m_ofrInterpret[128];  // ofr清算速度，对应待定
  char m_ofrQuoteType[4];    // ofr原始报价类型，对应待定
  char m_ofrBarginFlag[8];   // ofr可议价标志，对应 Entry.AskBargainFlag
  char m_ofrRelationFlag[8];  // ofr打包和 OCO标志，对应 Entry.AskRelationFlag
  char m_ofrExercise[8];    // ofr行权标志，对应 Entry.AskExerciseFlag
  char m_ofrCompanyId[33];  // ofr报价方，对应 Entry.askContributorID

  xQBMixedBestQuoteUnit_c() {
    memset(this, 0, sizeof(xQBMixedBestQuoteUnit_c));
    // 		memset(m_bondkey, 0, sizeof(m_bondkey));
    // 		memset(m_listedmarket, 0, sizeof(m_listedmarket));
    // 		memset(m_messageSeq, 0, sizeof(m_messageSeq));
    // 		memset(m_contributorId, 0, sizeof(m_contributorId));
    // 		m_version = 0;
    // 		m_modifyTime = 0;
  };
};
struct xQBMixedBestQuoteAck_c {
  std::list<xQBMixedBestQuoteUnit_c> m_list;
};

// E_FID_QB_ThirdPartyGuarantee_QRY = 50718,	//三方担保人查询
// 请求
typedef struct xQBThirdPartyGuaranteeListReq_t {
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  xQBThirdPartyGuaranteeListReq_t() {
    memset(m_UserId, 0, sizeof(m_UserId));
    memset(m_CompanyId, 0, sizeof(m_CompanyId));
  }
} QBThirdPartyGuaranteeListReq_t, *PQBThirdPartyGuaranteeListReq_t;

// 应答
typedef struct _tagQBThirdPartyGuarantee {
  char m_bondkey[32 + 1];      // 产品ID== bondkey
  char m_listedmarket[8];      // 市场代码
  char m_institution_code[8];  // 担保人代码
  char m_area[30];             // 担保人地区
  _tagQBThirdPartyGuarantee() {
    memset(this, 0, sizeof(_tagQBThirdPartyGuarantee));
  };
} QBThirdPartyGuarantee;

class xQBThirdPartyGuaranteeListAck_c {
 public:
  char m_UserId[32 + 1];     // 用户id，32UUID
  char m_CompanyId[32 + 1];  // 用户所属机构ID
  std::list<QBThirdPartyGuarantee> m_List;
  xQBThirdPartyGuaranteeListAck_c() {
    memset(m_UserId, 0, 33);
    memset(m_CompanyId, 0, 33);
  };
};

// E_FID_QB_SECTOR_BOND_REQ = 50720,			//板块查询
// 请求
struct SectorBondReq {
  char m_userId[32 + 1];  // 用户id，32UUID
  std::vector<std::string> m_sectorList;
  _InitializePureStruct(SectorBondReq)
};

// 应答
struct SectorBondUnit {
  // char m_bondkey[32 + 1];     //产品ID== bondkey
  // char m_listedmarket[8];     //市场代码
  char m_comBondCode[32];
  char m_sectorCode[50];  // 板块代码,多个板块使用 | 分割
  _InitializePureStruct(SectorBondUnit)
};

struct SectorBondAck {
  char m_userId[32 + 1];  // 用户id，32UUID
  std::list<SectorBondUnit> m_bondList;
  SectorBondAck(){_InitializeString(m_userId)};
};

// end
#endif
